.
+- Click **Create Issue** - Please provide as much information as possible about the issue type and how to reproduce it.
+
+Bug reports in JIRA for all driver projects (i.e. NODE, PYTHON, CSHARP, JAVA) and the
+Core Server (i.e. SERVER) project are **public**.
+
+### Questions and Bug Reports
+
+ * mailing list: https://groups.google.com/forum/#!forum/node-mongodb-native
+ * jira: http://jira.mongodb.org/
+
+### Change Log
+
+http://jira.mongodb.org/browse/NODE
+
+QuickStart
+==========
+The quick start guide will show you how to setup a simple application using node.js and MongoDB. It scope is only how to set up the driver and perform the simple crud operations. For more in depth coverage we encourage reading the tutorials.
+
+Create the package.json file
+----------------------------
+Let's create a directory where our application will live. In our case we will put this under our projects directory.
+
+```
+mkdir myproject
+cd myproject
+```
+
+Enter the following command and answer the questions to create the initial structure for your new project
+
+```
+npm init
+```
+
+Next we need to edit the generated package.json file to add the dependency for the MongoDB driver. The package.json file below is just an example and your will look different depending on how you answered the questions after entering `npm init`
+
+```
+{
+ "name": "myproject",
+ "version": "1.0.0",
+ "description": "My first project",
+ "main": "index.js",
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/christkv/myfirstproject.git"
+ },
+ "dependencies": {
+ "mongodb": "~2.0"
+ },
+ "author": "Christian Kvalheim",
+ "license": "Apache 2.0",
+ "bugs": {
+ "url": "https://github.com/christkv/myfirstproject/issues"
+ },
+ "homepage": "https://github.com/christkv/myfirstproject"
+}
+```
+
+Save the file and return to the shell or command prompt and use **NPM** to install all the dependencies.
+
+```
+npm install
+```
+
+You should see **NPM** download a lot of files. Once it's done you'll find all the downloaded packages under the **node_modules** directory.
+
+Booting up a MongoDB Server
+---------------------------
+Let's boot up a MongoDB server instance. Download the right MongoDB version from [MongoDB](http://www.mongodb.org), open a new shell or command line and ensure the **mongod** command is in the shell or command line path. Now let's create a database directory (in our case under **/data**).
+
+```
+mongod --dbpath=/data --port 27017
+```
+
+You should see the **mongod** process start up and print some status information.
+
+Connecting to MongoDB
+---------------------
+Let's create a new **app.js** file that we will use to show the basic CRUD operations using the MongoDB driver.
+
+First let's add code to connect to the server and the database **myproject**.
+
+```js
+var MongoClient = require('mongodb').MongoClient
+ , assert = require('assert');
+
+// Connection URL
+var url = 'mongodb://localhost:27017/myproject';
+// Use connect method to connect to the Server
+MongoClient.connect(url, function(err, db) {
+ assert.equal(null, err);
+ console.log("Connected correctly to server");
+
+ db.close();
+});
+```
+
+Given that you booted up the **mongod** process earlier the application should connect successfully and print **Connected correctly to server** to the console.
+
+Let's Add some code to show the different CRUD operations available.
+
+Inserting a Document
+--------------------
+Let's create a function that will insert some documents for us.
+
+```js
+var insertDocuments = function(db, callback) {
+ // Get the documents collection
+ var collection = db.collection('documents');
+ // Insert some documents
+ collection.insert([
+ {a : 1}, {a : 2}, {a : 3}
+ ], function(err, result) {
+ assert.equal(err, null);
+ assert.equal(3, result.result.n);
+ assert.equal(3, result.ops.length);
+ console.log("Inserted 3 documents into the document collection");
+ callback(result);
+ });
+}
+```
+
+The insert command will return a results object that contains several fields that might be useful.
+
+* **result** Contains the result document from MongoDB
+* **ops** Contains the documents inserted with added **_id** fields
+* **connection** Contains the connection used to perform the insert
+
+Let's add call the **insertDocuments** command to the **MongoClient.connect** method callback.
+
+```js
+var MongoClient = require('mongodb').MongoClient
+ , assert = require('assert');
+
+// Connection URL
+var url = 'mongodb://localhost:27017/myproject';
+// Use connect method to connect to the Server
+MongoClient.connect(url, function(err, db) {
+ assert.equal(null, err);
+ console.log("Connected correctly to server");
+
+ insertDocuments(db, function() {
+ db.close();
+ });
+});
+```
+
+We can now run the update **app.js** file.
+
+```
+node app.js
+```
+
+You should see the following output after running the **app.js** file.
+
+```
+Connected correctly to server
+Inserted 3 documents into the document collection
+```
+
+Updating a document
+-------------------
+Let's look at how to do a simple document update by adding a new field **b** to the document that has the field **a** set to **2**.
+
+```js
+var updateDocument = function(db, callback) {
+ // Get the documents collection
+ var collection = db.collection('documents');
+ // Update document where a is 2, set b equal to 1
+ collection.update({ a : 2 }
+ , { $set: { b : 1 } }, function(err, result) {
+ assert.equal(err, null);
+ assert.equal(1, result.result.n);
+ console.log("Updated the document with the field a equal to 2");
+ callback(result);
+ });
+}
+```
+
+The method will update the first document where the field **a** is equal to **2** by adding a new field **b** to the document set to **1**. Let's update the callback function from **MongoClient.connect** to include the update method.
+
+```js
+var MongoClient = require('mongodb').MongoClient
+ , assert = require('assert');
+
+// Connection URL
+var url = 'mongodb://localhost:27017/myproject';
+// Use connect method to connect to the Server
+MongoClient.connect(url, function(err, db) {
+ assert.equal(null, err);
+ console.log("Connected correctly to server");
+
+ insertDocuments(db, function() {
+ updateDocument(db, function() {
+ db.close();
+ });
+ });
+});
+```
+
+Remove a document
+-----------------
+Next lets remove the document where the field **a** equals to **3**.
+
+```js
+var removeDocument = function(db, callback) {
+ // Get the documents collection
+ var collection = db.collection('documents');
+ // Insert some documents
+ collection.remove({ a : 3 }, function(err, result) {
+ assert.equal(err, null);
+ assert.equal(1, result.result.n);
+ console.log("Removed the document with the field a equal to 3");
+ callback(result);
+ });
+}
+```
+
+This will remove the first document where the field **a** equals to **3**. Let's add the method to the **MongoClient.connect** callback function.
+
+```js
+var MongoClient = require('mongodb').MongoClient
+ , assert = require('assert');
+
+// Connection URL
+var url = 'mongodb://localhost:27017/myproject';
+// Use connect method to connect to the Server
+MongoClient.connect(url, function(err, db) {
+ assert.equal(null, err);
+ console.log("Connected correctly to server");
+
+ insertDocuments(db, function() {
+ updateDocument(db, function() {
+ removeDocument(db, function() {
+ db.close();
+ });
+ });
+ });
+});
+```
+
+Finally let's retrieve all the documents using a simple find.
+
+Find All Documents
+------------------
+We will finish up the Quickstart CRUD methods by performing a simple query that returns all the documents matching the query.
+
+```js
+var findDocuments = function(db, callback) {
+ // Get the documents collection
+ var collection = db.collection('documents');
+ // Find some documents
+ collection.find({}).toArray(function(err, docs) {
+ assert.equal(err, null);
+ assert.equal(2, docs.length);
+ console.log("Found the following records");
+ console.dir(docs);
+ callback(docs);
+ });
+}
+```
+
+This query will return all the documents in the **documents** collection. Since we removed a document the total documents returned is **2**. Finally let's add the findDocument method to the **MongoClient.connect** callback.
+
+```js
+var MongoClient = require('mongodb').MongoClient
+ , assert = require('assert');
+
+// Connection URL
+var url = 'mongodb://localhost:27017/myproject';
+// Use connect method to connect to the Server
+MongoClient.connect(url, function(err, db) {
+ assert.equal(null, err);
+ console.log("Connected correctly to server");
+
+ insertDocuments(db, function() {
+ updateDocument(db, function() {
+ removeDocument(db, function() {
+ findDocuments(db, function() {
+ db.close();
+ });
+ });
+ });
+ });
+});
+```
+
+This concludes the QuickStart of connecting and performing some Basic operations using the MongoDB Node.js driver. For more detailed information you can look at the tutorials covering more specific topics of interest.
+
+## Next Steps
+
+ * [MongoDB Documentation](http://mongodb.org/)
+ * [Read about Schemas](http://learnmongodbthehardway.com/)
+ * [Star us on GitHub](https://github.com/mongodb/node-mongodb-native)
diff --git a/server/node_modules/mongodb/conf.json b/server/node_modules/mongodb/conf.json
new file mode 100755
index 00000000..73cf6921
--- /dev/null
+++ b/server/node_modules/mongodb/conf.json
@@ -0,0 +1,65 @@
+{
+ "plugins": ["plugins/markdown", "docs/lib/jsdoc/examples_plugin.js"],
+ "source": {
+ "include": [
+ "test/functional/operation_example_tests.js",
+ "lib/admin.js",
+ "lib/aggregation_cursor.js",
+ "lib/command_cursor.js",
+ "lib/collection.js",
+ "lib/cursor.js",
+ "lib/db.js",
+ "lib/mongo_client.js",
+ "lib/mongos.js",
+ "lib/read_preference.js",
+ "lib/replset.js",
+ "lib/server.js",
+ "lib/bulk/common.js",
+ "lib/bulk/ordered.js",
+ "lib/bulk/unordered.js",
+ "lib/gridfs/grid_store.js",
+ "node_modules/mongodb-core/lib/connection/logger.js",
+ "node_modules/bson/lib/bson/binary.js",
+ "node_modules/bson/lib/bson/code.js",
+ "node_modules/bson/lib/bson/db_ref.js",
+ "node_modules/bson/lib/bson/double.js",
+ "node_modules/bson/lib/bson/long.js",
+ "node_modules/bson/lib/bson/objectid.js",
+ "node_modules/bson/lib/bson/symbol.js",
+ "node_modules/bson/lib/bson/timestamp.js",
+ "node_modules/bson/lib/bson/max_key.js",
+ "node_modules/bson/lib/bson/min_key.js"
+ ]
+ },
+ "templates": {
+ "cleverLinks": true,
+ "monospaceLinks": true,
+ "default": {
+ "outputSourceFiles" : true
+ },
+ "applicationName": "Node.js MongoDB Driver API",
+ "disqus": true,
+ "googleAnalytics": "UA-29229787-1",
+ "openGraph": {
+ "title": "",
+ "type": "website",
+ "image": "",
+ "site_name": "",
+ "url": ""
+ },
+ "meta": {
+ "title": "",
+ "description": "",
+ "keyword": ""
+ },
+ "linenums": true
+ },
+ "markdown": {
+ "parser": "gfm",
+ "hardwrap": true,
+ "tags": ["examples"]
+ },
+ "examples": {
+ "indent": 4
+ }
+}
\ No newline at end of file
diff --git a/server/node_modules/mongodb/index.js b/server/node_modules/mongodb/index.js
new file mode 100755
index 00000000..a1df2e25
--- /dev/null
+++ b/server/node_modules/mongodb/index.js
@@ -0,0 +1,39 @@
+// Core module
+var core = require('mongodb-core');
+
+// Set up the connect function
+var connect = require('./lib/mongo_client').connect;
+
+// Expose error class
+connect.MongoError = core.MongoError;
+
+// Actual driver classes exported
+connect.MongoClient = require('./lib/mongo_client');
+connect.Db = require('./lib/db');
+connect.Collection = require('./lib/collection');
+connect.Server = require('./lib/server');
+connect.ReplSet = require('./lib/replset');
+connect.Mongos = require('./lib/mongos');
+connect.ReadPreference = require('./lib/read_preference');
+connect.GridStore = require('./lib/gridfs/grid_store');
+connect.Chunk = require('./lib/gridfs/chunk');
+connect.Logger = core.Logger;
+connect.Cursor = require('./lib/cursor');
+
+// BSON types exported
+connect.Binary = core.BSON.Binary;
+connect.Code = core.BSON.Code;
+connect.DBRef = core.BSON.DBRef;
+connect.Double = core.BSON.Double;
+connect.Long = core.BSON.Long;
+connect.MinKey = core.BSON.MinKey;
+connect.MaxKey = core.BSON.MaxKey;
+connect.ObjectID = core.BSON.ObjectID;
+connect.ObjectId = core.BSON.ObjectID;
+connect.Symbol = core.BSON.Symbol;
+connect.Timestamp = core.BSON.Timestamp;
+
+// Add connect method
+connect.connect = connect;
+// Set our exports to be the connect function
+module.exports = connect;
\ No newline at end of file
diff --git a/server/node_modules/mongodb/lib/admin.js b/server/node_modules/mongodb/lib/admin.js
new file mode 100755
index 00000000..a0c898a5
--- /dev/null
+++ b/server/node_modules/mongodb/lib/admin.js
@@ -0,0 +1,347 @@
+"use strict";
+
+var toError = require('./utils').toError;
+
+/**
+ * @fileOverview The **Admin** class is an internal class that allows convenient access to
+ * the admin functionality and commands for MongoDB.
+ *
+ * **ADMIN Cannot directly be instantiated**
+ * @example
+ * var MongoClient = require('mongodb').MongoClient,
+ * test = require('assert');
+ * // Connection url
+ * var url = 'mongodb://localhost:27017/test';
+ * // Connect using MongoClient
+ * MongoClient.connect(url, function(err, db) {
+ * // Use the admin database for the operation
+ * var adminDb = db.admin();
+ *
+ * // List all the available databases
+ * adminDb.listDatabases(function(err, dbs) {
+ * test.equal(null, err);
+ * test.ok(dbs.databases.length > 0);
+ * db.close();
+ * });
+ * });
+ */
+
+/**
+ * Create a new Admin instance (INTERNAL TYPE, do not instantiate directly)
+ * @class
+ * @return {Admin} a collection instance.
+ */
+var Admin = function(db, topology) {
+ if(!(this instanceof Admin)) return new Admin(db, topology);
+ var self = this;
+
+ // Internal state
+ this.s = {
+ db: db
+ , topology: topology
+ }
+}
+
+/**
+ * The callback format for results
+ * @callback Admin~resultCallback
+ * @param {MongoError} error An error instance representing the error during the execution.
+ * @param {object} result The result object if the command was executed successfully.
+ */
+
+/**
+ * Execute a command
+ * @method
+ * @param {object} command The command hash
+ * @param {object} [options=null] Optional settings.
+ * @param {(ReadPreference|string)} [options.readPreference=null] The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).
+ * @param {number} [options.maxTimeMS=null] Number of milliseconds to wait before aborting the query.
+ * @param {Admin~resultCallback} callback The command result callback
+ * @return {null}
+ */
+Admin.prototype.command = function(command, options, callback) {
+ var args = Array.prototype.slice.call(arguments, 1);
+ callback = args.pop();
+ options = args.length ? args.shift() : {};
+
+ // Execute a command
+ this.s.db.executeDbAdminCommand(command, options, function(err, doc) {
+ return callback != null ? callback(err, doc) : null;
+ });
+}
+
+/**
+ * Retrieve the server information for the current
+ * instance of the db client
+ *
+ * @param {Admin~resultCallback} callback The command result callback
+ * @return {null}
+ */
+Admin.prototype.buildInfo = function(callback) {
+ this.serverInfo(callback);
+}
+
+/**
+ * Retrieve the server information for the current
+ * instance of the db client
+ *
+ * @param {Admin~resultCallback} callback The command result callback
+ * @return {null}
+ */
+Admin.prototype.serverInfo = function(callback) {
+ this.s.db.executeDbAdminCommand({buildinfo:1}, function(err, doc) {
+ if(err != null) return callback(err, null);
+ return callback(null, doc);
+ });
+}
+
+/**
+ * Retrieve this db's server status.
+ *
+ * @param {Admin~resultCallback} callback The command result callback
+ * @return {null}
+ */
+Admin.prototype.serverStatus = function(callback) {
+ var self = this;
+
+ this.s.db.executeDbAdminCommand({serverStatus: 1}, function(err, doc) {
+ if(err == null && doc.ok === 1) {
+ callback(null, doc);
+ } else {
+ if(err) return callback(err, false);
+ return callback(toError(doc), false);
+ }
+ });
+};
+
+/**
+ * Retrieve the current profiling Level for MongoDB
+ *
+ * @param {Admin~resultCallback} callback The command result callback
+ * @return {null}
+ */
+Admin.prototype.profilingLevel = function(callback) {
+ var self = this;
+
+ this.s.db.executeDbAdminCommand({profile:-1}, function(err, doc) {
+ doc = doc;
+
+ if(err == null && doc.ok === 1) {
+ var was = doc.was;
+ if(was == 0) return callback(null, "off");
+ if(was == 1) return callback(null, "slow_only");
+ if(was == 2) return callback(null, "all");
+ return callback(new Error("Error: illegal profiling level value " + was), null);
+ } else {
+ err != null ? callback(err, null) : callback(new Error("Error with profile command"), null);
+ }
+ });
+};
+
+/**
+ * Ping the MongoDB server and retrieve results
+ *
+ * @param {Admin~resultCallback} callback The command result callback
+ * @return {null}
+ */
+Admin.prototype.ping = function(options, callback) {
+ var args = Array.prototype.slice.call(arguments, 0);
+ this.s.db.executeDbAdminCommand({ping: 1}, args.pop());
+}
+
+/**
+ * Authenticate a user against the server.
+ * @method
+ * @param {string} username The username.
+ * @param {string} [password] The password.
+ * @param {Admin~resultCallback} callback The command result callback
+ * @return {null}
+ */
+Admin.prototype.authenticate = function(username, password, callback) {
+ this.s.db.authenticate(username, password, {authdb: 'admin'}, function(err, doc) {
+ return callback(err, doc);
+ })
+}
+
+/**
+ * Logout user from server, fire off on all connections and remove all auth info
+ * @method
+ * @param {Admin~resultCallback} callback The command result callback
+ * @return {null}
+ */
+Admin.prototype.logout = function(callback) {
+ this.s.db.logout({authdb: 'admin'}, function(err, doc) {
+ return callback(err, doc);
+ })
+}
+
+/**
+ * Add a user to the database.
+ * @method
+ * @param {string} username The username.
+ * @param {string} password The password.
+ * @param {object} [options=null] Optional settings.
+ * @param {(number|string)} [options.w=null] The write concern.
+ * @param {number} [options.wtimeout=null] The write concern timeout.
+ * @param {boolean} [options.j=false] Specify a journal write concern.
+ * @param {boolean} [options.fsync=false] Specify a file sync write concern.
+ * @param {object} [options.customData=null] Custom data associated with the user (only Mongodb 2.6 or higher)
+ * @param {object[]} [options.roles=null] Roles associated with the created user (only Mongodb 2.6 or higher)
+ * @param {Admin~resultCallback} callback The command result callback
+ * @return {null}
+ */
+Admin.prototype.addUser = function(username, password, options, callback) {
+ var args = Array.prototype.slice.call(arguments, 2);
+ callback = args.pop();
+ options = args.length ? args.shift() : {};
+ // Set the db name to admin
+ options.dbName = 'admin';
+ // Add user
+ this.s.db.addUser(username, password, options, function(err, doc) {
+ return callback(err, doc);
+ })
+}
+
+/**
+ * Remove a user from a database
+ * @method
+ * @param {string} username The username.
+ * @param {object} [options=null] Optional settings.
+ * @param {(number|string)} [options.w=null] The write concern.
+ * @param {number} [options.wtimeout=null] The write concern timeout.
+ * @param {boolean} [options.j=false] Specify a journal write concern.
+ * @param {boolean} [options.fsync=false] Specify a file sync write concern.
+ * @param {Admin~resultCallback} callback The command result callback
+ * @return {null}
+ */
+Admin.prototype.removeUser = function(username, options, callback) {
+ var self = this;
+ var args = Array.prototype.slice.call(arguments, 1);
+ callback = args.pop();
+ options = args.length ? args.shift() : {};
+ options.dbName = 'admin';
+
+ this.s.db.removeUser(username, options, function(err, doc) {
+ return callback(err, doc);
+ })
+}
+
+/**
+ * Set the current profiling level of MongoDB
+ *
+ * @param {string} level The new profiling level (off, slow_only, all).
+ * @param {Admin~resultCallback} callback The command result callback.
+ * @return {null}
+ */
+Admin.prototype.setProfilingLevel = function(level, callback) {
+ var self = this;
+ var command = {};
+ var profile = 0;
+
+ if(level == "off") {
+ profile = 0;
+ } else if(level == "slow_only") {
+ profile = 1;
+ } else if(level == "all") {
+ profile = 2;
+ } else {
+ return callback(new Error("Error: illegal profiling level value " + level));
+ }
+
+ // Set up the profile number
+ command['profile'] = profile;
+
+ this.s.db.executeDbAdminCommand(command, function(err, doc) {
+ doc = doc;
+
+ if(err == null && doc.ok === 1)
+ return callback(null, level);
+ return err != null ? callback(err, null) : callback(new Error("Error with profile command"), null);
+ });
+};
+
+/**
+ * Retrive the current profiling information for MongoDB
+ *
+ * @param {Admin~resultCallback} callback The command result callback.
+ * @return {null}
+ */
+Admin.prototype.profilingInfo = function(callback) {
+ try {
+ this.s.topology.cursor("admin.system.profile", { find: 'system.profile', query: {}}, {}).toArray(callback);
+ } catch (err) {
+ return callback(err, null);
+ }
+};
+
+/**
+ * Validate an existing collection
+ *
+ * @param {string} collectionName The name of the collection to validate.
+ * @param {object} [options=null] Optional settings.
+ * @param {Admin~resultCallback} callback The command result callback.
+ * @return {null}
+ */
+Admin.prototype.validateCollection = function(collectionName, options, callback) {
+ var args = Array.prototype.slice.call(arguments, 1);
+ callback = args.pop();
+ options = args.length ? args.shift() : {};
+
+ var self = this;
+ var command = {validate: collectionName};
+ var keys = Object.keys(options);
+
+ // Decorate command with extra options
+ for(var i = 0; i < keys.length; i++) {
+ if(options.hasOwnProperty(keys[i])) {
+ command[keys[i]] = options[keys[i]];
+ }
+ }
+
+ this.s.db.command(command, function(err, doc) {
+ if(err != null) return callback(err, null);
+
+ if(doc.ok === 0)
+ return callback(new Error("Error with validate command"), null);
+ if(doc.result != null && doc.result.constructor != String)
+ return callback(new Error("Error with validation data"), null);
+ if(doc.result != null && doc.result.match(/exception|corrupt/) != null)
+ return callback(new Error("Error: invalid collection " + collectionName), null);
+ if(doc.valid != null && !doc.valid)
+ return callback(new Error("Error: invalid collection " + collectionName), null);
+
+ return callback(null, doc);
+ });
+};
+
+/**
+ * List the available databases
+ *
+ * @param {Admin~resultCallback} callback The command result callback.
+ * @return {null}
+ */
+Admin.prototype.listDatabases = function(callback) {
+ this.s.db.executeDbAdminCommand({listDatabases:1}, {}, function(err, doc) {
+ if(err != null) return callback(err, null);
+ return callback(null, doc);
+ });
+}
+
+/**
+ * Get ReplicaSet status
+ *
+ * @param {Admin~resultCallback} callback The command result callback.
+ * @return {null}
+ */
+Admin.prototype.replSetGetStatus = function(callback) {
+ var self = this;
+
+ this.s.db.executeDbAdminCommand({replSetGetStatus:1}, function(err, doc) {
+ if(err == null && doc.ok === 1)
+ return callback(null, doc);
+ if(err) return callback(err, false);
+ return callback(toError(doc), false);
+ });
+};
+
+module.exports = Admin;
\ No newline at end of file
diff --git a/server/node_modules/mongodb/lib/aggregation_cursor.js b/server/node_modules/mongodb/lib/aggregation_cursor.js
new file mode 100755
index 00000000..2b1b3be1
--- /dev/null
+++ b/server/node_modules/mongodb/lib/aggregation_cursor.js
@@ -0,0 +1,397 @@
+"use strict";
+
+var inherits = require('util').inherits
+ , f = require('util').format
+ , toError = require('./utils').toError
+ , getSingleProperty = require('./utils').getSingleProperty
+ , formattedOrderClause = require('./utils').formattedOrderClause
+ , handleCallback = require('./utils').handleCallback
+ , Logger = require('mongodb-core').Logger
+ , EventEmitter = require('events').EventEmitter
+ , ReadPreference = require('./read_preference')
+ , MongoError = require('mongodb-core').MongoError
+ , Readable = require('stream').Readable || require('readable-stream').Readable
+ // , CoreCursor = require('mongodb-core').Cursor
+ , CoreCursor = require('./cursor')
+ , Query = require('mongodb-core').Query
+ , CoreReadPreference = require('mongodb-core').ReadPreference;
+
+/**
+ * @fileOverview The **AggregationCursor** class is an internal class that embodies an aggregation cursor on MongoDB
+ * allowing for iteration over the results returned from the underlying query. It supports
+ * one by one document iteration, conversion to an array or can be iterated as a Node 0.10.X
+ * or higher stream
+ *
+ * **AGGREGATIONCURSOR Cannot directly be instantiated**
+ * @example
+ * var MongoClient = require('mongodb').MongoClient,
+ * test = require('assert');
+ * // Connection url
+ * var url = 'mongodb://localhost:27017/test';
+ * // Connect using MongoClient
+ * MongoClient.connect(url, function(err, db) {
+ * // Create a collection we want to drop later
+ * var col = db.collection('createIndexExample1');
+ * // Insert a bunch of documents
+ * col.insert([{a:1, b:1}
+ * , {a:2, b:2}, {a:3, b:3}
+ * , {a:4, b:4}], {w:1}, function(err, result) {
+ * test.equal(null, err);
+ *
+ * // Show that duplicate records got dropped
+ * col.aggregation({}, {cursor: {}}).toArray(function(err, items) {
+ * test.equal(null, err);
+ * test.equal(4, items.length);
+ * db.close();
+ * });
+ * });
+ * });
+ */
+
+/**
+ * Namespace provided by the browser.
+ * @external Readable
+ */
+
+/**
+ * Creates a new Aggregation Cursor instance (INTERNAL TYPE, do not instantiate directly)
+ * @class
+ * @extends external:Readable
+ * @fires AggregationCursor#data
+ * @fires AggregationCursor#end
+ * @fires AggregationCursor#close
+ * @fires AggregationCursor#readable
+ * @return {AggregationCursor} an AggregationCursor instance.
+ */
+var AggregationCursor = function(bson, ns, cmd, options, topology, topologyOptions) {
+ CoreCursor.apply(this, Array.prototype.slice.call(arguments, 0));
+ var self = this;
+ var state = AggregationCursor.INIT;
+ var streamOptions = {};
+
+ // MaxTimeMS
+ var maxTimeMS = null;
+
+ // Set up
+ Readable.call(this, {objectMode: true});
+
+ // Internal state
+ this.s = {
+ // MaxTimeMS
+ maxTimeMS: maxTimeMS
+ // State
+ , state: state
+ // Stream options
+ , streamOptions: streamOptions
+ // BSON
+ , bson: bson
+ // Namespae
+ , ns: ns
+ // Command
+ , cmd: cmd
+ // Options
+ , options: options
+ // Topology
+ , topology: topology
+ // Topology Options
+ , topologyOptions: topologyOptions
+ }
+}
+
+/**
+ * AggregationCursor stream data event, fired for each document in the cursor.
+ *
+ * @event AggregationCursor#data
+ * @type {object}
+ */
+
+/**
+ * AggregationCursor stream end event
+ *
+ * @event AggregationCursor#end
+ * @type {null}
+ */
+
+/**
+ * AggregationCursor stream close event
+ *
+ * @event AggregationCursor#close
+ * @type {null}
+ */
+
+/**
+ * AggregationCursor stream readable event
+ *
+ * @event AggregationCursor#readable
+ * @type {null}
+ */
+
+// // Extend the Cursor
+// inherits(AggregationCursor, CoreCursor);
+
+// Inherit from Readable
+inherits(AggregationCursor, Readable);
+
+// Extend the Cursor
+for(var name in CoreCursor.prototype) {
+ AggregationCursor.prototype[name] = CoreCursor.prototype[name];
+}
+
+/**
+ * Set the batch size for the cursor.
+ * @method
+ * @param {number} value The batchSize for the cursor.
+ * @throws {MongoError}
+ * @return {AggregationCursor}
+ */
+AggregationCursor.prototype.batchSize = function(value) {
+ if(this.s.state == AggregationCursor.CLOSED || this.isDead()) throw new MongoError("Cursor is closed");
+ if(typeof value != 'number') throw new MongoError("batchSize requires an integer");
+ if(this.s.cmd.cursor) this.s.cmd.cursor.batchSize = value;
+ this.setCursorBatchSize(value);
+ return this;
+}
+
+/**
+ * Add a geoNear stage to the aggregation pipeline
+ * @method
+ * @param {object} document The geoNear stage document.
+ * @return {AggregationCursor}
+ */
+AggregationCursor.prototype.geoNear = function(document) {
+ this.s.cmd.pipeline.push({$geoNear: document});
+ return this;
+}
+
+/**
+ * Add a group stage to the aggregation pipeline
+ * @method
+ * @param {object} document The group stage document.
+ * @return {AggregationCursor}
+ */
+AggregationCursor.prototype.group = function(document) {
+ this.s.cmd.pipeline.push({$group: document});
+ return this;
+}
+
+/**
+ * Add a limit stage to the aggregation pipeline
+ * @method
+ * @param {number} value The state limit value.
+ * @return {AggregationCursor}
+ */
+AggregationCursor.prototype.limit = function(value) {
+ this.s.cmd.pipeline.push({$limit: value});
+ return this;
+}
+
+/**
+ * Add a match stage to the aggregation pipeline
+ * @method
+ * @param {object} document The match stage document.
+ * @return {AggregationCursor}
+ */
+AggregationCursor.prototype.match = function(document) {
+ this.s.cmd.pipeline.push({$match: document});
+ return this;
+}
+
+/**
+ * Add a maxTimeMS stage to the aggregation pipeline
+ * @method
+ * @param {number} value The state maxTimeMS value.
+ * @return {AggregationCursor}
+ */
+AggregationCursor.prototype.maxTimeMS = function(value) {
+ if(this.s.topology.lastIsMaster().minWireVersion > 2) {
+ this.s.cmd.maxTimeMS = value;
+ }
+ return this;
+}
+
+/**
+ * Add a out stage to the aggregation pipeline
+ * @method
+ * @param {number} destination The destination name.
+ * @return {AggregationCursor}
+ */
+AggregationCursor.prototype.out = function(destination) {
+ this.s.cmd.pipeline.push({$out: destination});
+ return this;
+}
+
+/**
+ * Add a project stage to the aggregation pipeline
+ * @method
+ * @param {object} document The project stage document.
+ * @return {AggregationCursor}
+ */
+AggregationCursor.prototype.project = function(document) {
+ this.s.cmd.pipeline.push({$project: document});
+ return this;
+}
+
+/**
+ * Add a redact stage to the aggregation pipeline
+ * @method
+ * @param {object} document The redact stage document.
+ * @return {AggregationCursor}
+ */
+AggregationCursor.prototype.redact = function(document) {
+ this.s.cmd.pipeline.push({$redact: document});
+ return this;
+}
+
+/**
+ * Add a skip stage to the aggregation pipeline
+ * @method
+ * @param {number} value The state skip value.
+ * @return {AggregationCursor}
+ */
+AggregationCursor.prototype.skip = function(value) {
+ this.s.cmd.pipeline.push({$skip: value});
+ return this;
+}
+
+/**
+ * Add a sort stage to the aggregation pipeline
+ * @method
+ * @param {object} document The sort stage document.
+ * @return {AggregationCursor}
+ */
+AggregationCursor.prototype.sort = function(document) {
+ this.s.cmd.pipeline.push({$sort: document});
+ return this;
+}
+
+/**
+ * Add a unwind stage to the aggregation pipeline
+ * @method
+ * @param {number} field The unwind field name.
+ * @return {AggregationCursor}
+ */
+AggregationCursor.prototype.unwind = function(field) {
+ this.s.cmd.pipeline.push({$unwind: field});
+ return this;
+}
+
+AggregationCursor.prototype.get = AggregationCursor.prototype.toArray;
+
+/**
+ * Get the next available document from the cursor, returns null if no more documents are available.
+ * @function AggregationCursor.prototype.next
+ * @param {AggregationCursor~resultCallback} callback The result callback.
+ * @throws {MongoError}
+ * @return {null}
+ */
+
+/**
+ * Set the new batchSize of the cursor
+ * @function AggregationCursor.prototype.setBatchSize
+ * @param {number} value The new batchSize for the cursor
+ * @return {null}
+ */
+
+/**
+ * Get the batchSize of the cursor
+ * @function AggregationCursor.prototype.batchSize
+ * @param {number} value The current batchSize for the cursor
+ * @return {null}
+ */
+
+/**
+ * The callback format for results
+ * @callback AggregationCursor~toArrayResultCallback
+ * @param {MongoError} error An error instance representing the error during the execution.
+ * @param {object[]} documents All the documents the satisfy the cursor.
+ */
+
+/**
+ * Returns an array of documents. The caller is responsible for making sure that there
+ * is enough memory to store the results. Note that the array only contain partial
+ * results when this cursor had been previouly accessed. In that case,
+ * cursor.rewind() can be used to reset the cursor.
+ * @method AggregationCursor.prototype.toArray
+ * @param {AggregationCursor~toArrayResultCallback} callback The result callback.
+ * @throws {MongoError}
+ * @return {null}
+ */
+
+/**
+ * The callback format for results
+ * @callback AggregationCursor~resultCallback
+ * @param {MongoError} error An error instance representing the error during the execution.
+ * @param {(object|null)} result The result object if the command was executed successfully.
+ */
+
+/**
+ * Iterates over all the documents for this cursor. As with **{cursor.toArray}**,
+ * not all of the elements will be iterated if this cursor had been previouly accessed.
+ * In that case, **{cursor.rewind}** can be used to reset the cursor. However, unlike
+ * **{cursor.toArray}**, the cursor will only hold a maximum of batch size elements
+ * at any given time if batch size is specified. Otherwise, the caller is responsible
+ * for making sure that the entire result can fit the memory.
+ * @method AggregationCursor.prototype.each
+ * @param {AggregationCursor~resultCallback} callback The result callback.
+ * @throws {MongoError}
+ * @return {null}
+ */
+
+/**
+ * Close the cursor, sending a KillCursor command and emitting close.
+ * @method AggregationCursor.prototype.close
+ * @param {AggregationCursor~resultCallback} [callback] The result callback.
+ * @return {null}
+ */
+
+/**
+ * Is the cursor closed
+ * @method AggregationCursor.prototype.isClosed
+ * @return {boolean}
+ */
+
+/**
+ * Execute the explain for the cursor
+ * @method AggregationCursor.prototype.explain
+ * @param {AggregationCursor~resultCallback} [callback] The result callback.
+ * @return {null}
+ */
+
+/**
+ * Clone the cursor
+ * @function AggregationCursor.prototype.clone
+ * @return {AggregationCursor}
+ */
+
+/**
+ * Resets the cursor
+ * @function AggregationCursor.prototype.rewind
+ * @return {AggregationCursor}
+ */
+
+/**
+ * The callback format for the forEach iterator method
+ * @callback AggregationCursor~iteratorCallback
+ * @param {Object} doc An emitted document for the iterator
+ */
+
+/**
+ * The callback error format for the forEach iterator method
+ * @callback AggregationCursor~endCallback
+ * @param {MongoError} error An error instance representing the error during the execution.
+ */
+
+/*
+ * Iterates over all the documents for this cursor using the iterator, callback pattern.
+ * @method AggregationCursor.prototype.forEach
+ * @param {AggregationCursor~iteratorCallback} iterator The iteration callback.
+ * @param {AggregationCursor~endCallback} callback The end callback.
+ * @throws {MongoError}
+ * @return {null}
+ */
+
+AggregationCursor.INIT = 0;
+AggregationCursor.OPEN = 1;
+AggregationCursor.CLOSED = 2;
+
+module.exports = AggregationCursor;
\ No newline at end of file
diff --git a/server/node_modules/mongodb/lib/bulk/common.js b/server/node_modules/mongodb/lib/bulk/common.js
new file mode 100755
index 00000000..d6f6dc5f
--- /dev/null
+++ b/server/node_modules/mongodb/lib/bulk/common.js
@@ -0,0 +1,393 @@
+"use strict";
+
+var utils = require('../utils');
+
+// Error codes
+var UNKNOWN_ERROR = 8;
+var INVALID_BSON_ERROR = 22;
+var WRITE_CONCERN_ERROR = 64;
+var MULTIPLE_ERROR = 65;
+
+// Insert types
+var INSERT = 1;
+var UPDATE = 2;
+var REMOVE = 3
+
+
+// Get write concern
+var writeConcern = function(target, col, options) {
+ if(options.w != null || options.j != null || options.fsync != null) {
+ target.writeConcern = options;
+ } else if(col.writeConcern.w != null || col.writeConcern.j != null || col.writeConcern.fsync != null) {
+ target.writeConcern = col.writeConcern;
+ }
+
+ return target
+}
+
+/**
+ * Helper function to define properties
+ * @ignore
+ */
+var defineReadOnlyProperty = function(self, name, value) {
+ Object.defineProperty(self, name, {
+ enumerable: true
+ , get: function() {
+ return value;
+ }
+ });
+}
+
+/**
+ * Keeps the state of a unordered batch so we can rewrite the results
+ * correctly after command execution
+ * @ignore
+ */
+var Batch = function(batchType, originalZeroIndex) {
+ this.originalZeroIndex = originalZeroIndex;
+ this.currentIndex = 0;
+ this.originalIndexes = [];
+ this.batchType = batchType;
+ this.operations = [];
+ this.size = 0;
+ this.sizeBytes = 0;
+}
+
+/**
+ * Wraps a legacy operation so we can correctly rewrite it's error
+ * @ignore
+ */
+var LegacyOp = function(batchType, operation, index) {
+ this.batchType = batchType;
+ this.index = index;
+ this.operation = operation;
+}
+
+/**
+ * Create a new BulkWriteResult instance (INTERNAL TYPE, do not instantiate directly)
+ *
+ * @class
+ * @property {boolean} ok Did bulk operation correctly execute
+ * @property {number} nInserted number of inserted documents
+ * @property {number} nUpdated number of documents updated logically
+ * @property {number} nUpserted Number of upserted documents
+ * @property {number} nModified Number of documents updated physically on disk
+ * @property {number} nRemoved Number of removed documents
+ * @return {BulkWriteResult} a BulkWriteResult instance
+ */
+var BulkWriteResult = function(bulkResult) {
+ defineReadOnlyProperty(this, "ok", bulkResult.ok);
+ defineReadOnlyProperty(this, "nInserted", bulkResult.nInserted);
+ defineReadOnlyProperty(this, "nUpserted", bulkResult.nUpserted);
+ defineReadOnlyProperty(this, "nMatched", bulkResult.nMatched);
+ defineReadOnlyProperty(this, "nModified", bulkResult.nModified);
+ defineReadOnlyProperty(this, "nRemoved", bulkResult.nRemoved);
+
+ /**
+ * Return an array of inserted ids
+ *
+ * @return {object[]}
+ */
+ this.getInsertedIds = function() {
+ return bulkResult.insertedIds;
+ }
+
+ /**
+ * Return an array of upserted ids
+ *
+ * @return {object[]}
+ */
+ this.getUpsertedIds = function() {
+ return bulkResult.upserted;
+ }
+
+ /**
+ * Return the upserted id at position x
+ *
+ * @param {number} index the number of the upserted id to return, returns undefined if no result for passed in index
+ * @return {object}
+ */
+ this.getUpsertedIdAt = function(index) {
+ return bulkResult.upserted[index];
+ }
+
+ /**
+ * Return raw internal result
+ *
+ * @return {object}
+ */
+ this.getRawResponse = function() {
+ return bulkResult;
+ }
+
+ /**
+ * Returns true if the bulk operation contains a write error
+ *
+ * @return {boolean}
+ */
+ this.hasWriteErrors = function() {
+ return bulkResult.writeErrors.length > 0;
+ }
+
+ /**
+ * Returns the number of write errors off the bulk operation
+ *
+ * @return {number}
+ */
+ this.getWriteErrorCount = function() {
+ return bulkResult.writeErrors.length;
+ }
+
+ /**
+ * Returns a specific write error object
+ *
+ * @return {WriteError}
+ */
+ this.getWriteErrorAt = function(index) {
+ if(index < bulkResult.writeErrors.length) {
+ return bulkResult.writeErrors[index];
+ }
+ return null;
+ }
+
+ /**
+ * Retrieve all write errors
+ *
+ * @return {object[]}
+ */
+ this.getWriteErrors = function() {
+ return bulkResult.writeErrors;
+ }
+
+ /**
+ * Retrieve lastOp if available
+ *
+ * @return {object}
+ */
+ this.getLastOp = function() {
+ return bulkResult.lastOp;
+ }
+
+ /**
+ * Retrieve the write concern error if any
+ *
+ * @return {WriteConcernError}
+ */
+ this.getWriteConcernError = function() {
+ if(bulkResult.writeConcernErrors.length == 0) {
+ return null;
+ } else if(bulkResult.writeConcernErrors.length == 1) {
+ // Return the error
+ return bulkResult.writeConcernErrors[0];
+ } else {
+
+ // Combine the errors
+ var errmsg = "";
+ for(var i = 0; i < bulkResult.writeConcernErrors.length; i++) {
+ var err = bulkResult.writeConcernErrors[i];
+ errmsg = errmsg + err.errmsg;
+
+ // TODO: Something better
+ if(i == 0) errmsg = errmsg + " and ";
+ }
+
+ return new WriteConcernError({ errmsg : errmsg, code : WRITE_CONCERN_ERROR });
+ }
+ }
+
+ this.toJSON = function() {
+ return bulkResult;
+ }
+
+ this.toString = function() {
+ return "BulkWriteResult(" + this.toJSON(bulkResult) + ")";
+ }
+
+ this.isOk = function() {
+ return bulkResult.ok == 1;
+ }
+}
+
+/**
+ * Create a new WriteConcernError instance (INTERNAL TYPE, do not instantiate directly)
+ *
+ * @class
+ * @property {number} code Write concern error code.
+ * @property {string} errmsg Write concern error message.
+ * @return {WriteConcernError} a WriteConcernError instance
+ */
+var WriteConcernError = function(err) {
+ if(!(this instanceof WriteConcernError)) return new WriteConcernError(err);
+
+ // Define properties
+ defineReadOnlyProperty(this, "code", err.code);
+ defineReadOnlyProperty(this, "errmsg", err.errmsg);
+
+ this.toJSON = function() {
+ return {code: err.code, errmsg: err.errmsg};
+ }
+
+ this.toString = function() {
+ return "WriteConcernError(" + err.errmsg + ")";
+ }
+}
+
+/**
+ * Create a new WriteError instance (INTERNAL TYPE, do not instantiate directly)
+ *
+ * @class
+ * @property {number} code Write concern error code.
+ * @property {number} index Write concern error original bulk operation index.
+ * @property {string} errmsg Write concern error message.
+ * @return {WriteConcernError} a WriteConcernError instance
+ */
+var WriteError = function(err) {
+ if(!(this instanceof WriteError)) return new WriteError(err);
+
+ // Define properties
+ defineReadOnlyProperty(this, "code", err.code);
+ defineReadOnlyProperty(this, "index", err.index);
+ defineReadOnlyProperty(this, "errmsg", err.errmsg);
+
+ //
+ // Define access methods
+ this.getOperation = function() {
+ return err.op;
+ }
+
+ this.toJSON = function() {
+ return {code: err.code, index: err.index, errmsg: err.errmsg, op: err.op};
+ }
+
+ this.toString = function() {
+ return "WriteError(" + JSON.stringify(this.toJSON()) + ")";
+ }
+}
+
+/**
+ * Merges results into shared data structure
+ * @ignore
+ */
+var mergeBatchResults = function(ordered, batch, bulkResult, err, result) {
+ // If we have an error set the result to be the err object
+ if(err) {
+ result = err;
+ } else if(result && result.result) {
+ result = result.result;
+ } else if(result == null) {
+ return;
+ }
+
+ // Do we have a top level error stop processing and return
+ if(result.ok == 0 && bulkResult.ok == 1) {
+ bulkResult.ok = 0;
+ // bulkResult.error = utils.toError(result);
+ var writeError = {
+ index: 0
+ , code: result.code || 0
+ , errmsg: result.message
+ , op: batch.operations[0]
+ };
+
+ bulkResult.writeErrors.push(new WriteError(writeError));
+ return;
+ } else if(result.ok == 0 && bulkResult.ok == 0) {
+ return;
+ }
+
+ // Add lastop if available
+ if(result.lastOp) {
+ bulkResult.lastOp = result.lastOp;
+ }
+
+ // If we have an insert Batch type
+ if(batch.batchType == INSERT && result.n) {
+ bulkResult.nInserted = bulkResult.nInserted + result.n;
+ }
+
+ // If we have an insert Batch type
+ if(batch.batchType == REMOVE && result.n) {
+ bulkResult.nRemoved = bulkResult.nRemoved + result.n;
+ }
+
+ var nUpserted = 0;
+
+ // We have an array of upserted values, we need to rewrite the indexes
+ if(Array.isArray(result.upserted)) {
+ nUpserted = result.upserted.length;
+
+ for(var i = 0; i < result.upserted.length; i++) {
+ bulkResult.upserted.push({
+ index: result.upserted[i].index + batch.originalZeroIndex
+ , _id: result.upserted[i]._id
+ });
+ }
+ } else if(result.upserted) {
+
+ nUpserted = 1;
+
+ bulkResult.upserted.push({
+ index: batch.originalZeroIndex
+ , _id: result.upserted
+ });
+ }
+
+ // If we have an update Batch type
+ if(batch.batchType == UPDATE && result.n) {
+ var nModified = result.nModified;
+ bulkResult.nUpserted = bulkResult.nUpserted + nUpserted;
+ bulkResult.nMatched = bulkResult.nMatched + (result.n - nUpserted);
+
+ if(typeof nModified == 'number') {
+ bulkResult.nModified = bulkResult.nModified + nModified;
+ } else {
+ bulkResult.nModified = null;
+ }
+ }
+
+ if(Array.isArray(result.writeErrors)) {
+ for(var i = 0; i < result.writeErrors.length; i++) {
+
+ var writeError = {
+ index: batch.originalZeroIndex + result.writeErrors[i].index
+ , code: result.writeErrors[i].code
+ , errmsg: result.writeErrors[i].errmsg
+ , op: batch.operations[result.writeErrors[i].index]
+ };
+
+ bulkResult.writeErrors.push(new WriteError(writeError));
+ }
+ }
+
+ if(result.writeConcernError) {
+ bulkResult.writeConcernErrors.push(new WriteConcernError(result.writeConcernError));
+ }
+}
+
+//
+// Clone the options
+var cloneOptions = function(options) {
+ var clone = {};
+ var keys = Object.keys(options);
+ for(var i = 0; i < keys.length; i++) {
+ clone[keys[i]] = options[keys[i]];
+ }
+
+ return clone;
+}
+
+// Exports symbols
+exports.BulkWriteResult = BulkWriteResult;
+exports.WriteError = WriteError;
+exports.Batch = Batch;
+exports.LegacyOp = LegacyOp;
+exports.mergeBatchResults = mergeBatchResults;
+exports.cloneOptions = cloneOptions;
+exports.writeConcern = writeConcern;
+exports.INVALID_BSON_ERROR = INVALID_BSON_ERROR;
+exports.WRITE_CONCERN_ERROR = WRITE_CONCERN_ERROR;
+exports.MULTIPLE_ERROR = MULTIPLE_ERROR;
+exports.UNKNOWN_ERROR = UNKNOWN_ERROR;
+exports.INSERT = INSERT;
+exports.UPDATE = UPDATE;
+exports.REMOVE = REMOVE;
\ No newline at end of file
diff --git a/server/node_modules/mongodb/lib/bulk/ordered.js b/server/node_modules/mongodb/lib/bulk/ordered.js
new file mode 100755
index 00000000..32380a01
--- /dev/null
+++ b/server/node_modules/mongodb/lib/bulk/ordered.js
@@ -0,0 +1,470 @@
+"use strict";
+
+var common = require('./common')
+ , utils = require('../utils')
+ , toError = require('../utils').toError
+ , f = require('util').format
+ , shallowClone = utils.shallowClone
+ , WriteError = common.WriteError
+ , BulkWriteResult = common.BulkWriteResult
+ , LegacyOp = common.LegacyOp
+ , ObjectID = require('mongodb-core').BSON.ObjectID
+ , Batch = common.Batch
+ , mergeBatchResults = common.mergeBatchResults;
+
+/**
+ * Create a FindOperatorsOrdered instance (INTERNAL TYPE, do not instantiate directly)
+ * @class
+ * @return {FindOperatorsOrdered} a FindOperatorsOrdered instance.
+ */
+var FindOperatorsOrdered = function(self) {
+ this.s = self.s;
+}
+
+/**
+ * Add a single update document to the bulk operation
+ *
+ * @method
+ * @param {object} doc update operations
+ * @throws {MongoError}
+ * @return {OrderedBulkOperation}
+ */
+FindOperatorsOrdered.prototype.update = function(updateDocument) {
+ // Perform upsert
+ var upsert = typeof this.s.currentOp.upsert == 'boolean' ? this.s.currentOp.upsert : false;
+
+ // Establish the update command
+ var document = {
+ q: this.s.currentOp.selector
+ , u: updateDocument
+ , multi: true
+ , upsert: upsert
+ }
+
+ // Clear out current Op
+ this.s.currentOp = null;
+ // Add the update document to the list
+ return addToOperationsList(this, common.UPDATE, document);
+}
+
+/**
+ * Add a single update one document to the bulk operation
+ *
+ * @method
+ * @param {object} doc update operations
+ * @throws {MongoError}
+ * @return {OrderedBulkOperation}
+ */
+FindOperatorsOrdered.prototype.updateOne = function(updateDocument) {
+ // Perform upsert
+ var upsert = typeof this.s.currentOp.upsert == 'boolean' ? this.s.currentOp.upsert : false;
+
+ // Establish the update command
+ var document = {
+ q: this.s.currentOp.selector
+ , u: updateDocument
+ , multi: false
+ , upsert: upsert
+ }
+
+ // Clear out current Op
+ this.s.currentOp = null;
+ // Add the update document to the list
+ return addToOperationsList(this, common.UPDATE, document);
+}
+
+/**
+ * Add a replace one operation to the bulk operation
+ *
+ * @method
+ * @param {object} doc the new document to replace the existing one with
+ * @throws {MongoError}
+ * @return {OrderedBulkOperation}
+ */
+FindOperatorsOrdered.prototype.replaceOne = function(updateDocument) {
+ this.updateOne(updateDocument);
+}
+
+/**
+ * Upsert modifier for update bulk operation
+ *
+ * @method
+ * @throws {MongoError}
+ * @return {FindOperatorsOrdered}
+ */
+FindOperatorsOrdered.prototype.upsert = function() {
+ this.s.currentOp.upsert = true;
+ return this;
+}
+
+/**
+ * Add a remove one operation to the bulk operation
+ *
+ * @method
+ * @throws {MongoError}
+ * @return {OrderedBulkOperation}
+ */
+FindOperatorsOrdered.prototype.deleteOne = function() {
+ // Establish the update command
+ var document = {
+ q: this.s.currentOp.selector
+ , limit: 1
+ }
+
+ // Clear out current Op
+ this.s.currentOp = null;
+ // Add the remove document to the list
+ return addToOperationsList(this, common.REMOVE, document);
+}
+
+// Backward compatibility
+FindOperatorsOrdered.prototype.removeOne = FindOperatorsOrdered.prototype.deleteOne;
+
+/**
+ * Add a remove operation to the bulk operation
+ *
+ * @method
+ * @throws {MongoError}
+ * @return {OrderedBulkOperation}
+ */
+FindOperatorsOrdered.prototype.delete = function() {
+ // Establish the update command
+ var document = {
+ q: this.s.currentOp.selector
+ , limit: 0
+ }
+
+ // Clear out current Op
+ this.s.currentOp = null;
+ // Add the remove document to the list
+ return addToOperationsList(this, common.REMOVE, document);
+}
+
+// Backward compatibility
+FindOperatorsOrdered.prototype.remove = FindOperatorsOrdered.prototype.delete;
+
+// Add to internal list of documents
+var addToOperationsList = function(_self, docType, document) {
+ // Get the bsonSize
+ var bsonSize = _self.s.bson.calculateObjectSize(document, false);
+
+ // Throw error if the doc is bigger than the max BSON size
+ if(bsonSize >= _self.s.maxBatchSizeBytes) throw toError("document is larger than the maximum size " + _self.s.maxBatchSizeBytes);
+ // Create a new batch object if we don't have a current one
+ if(_self.s.currentBatch == null) _self.s.currentBatch = new Batch(docType, _self.s.currentIndex);
+
+ // Check if we need to create a new batch
+ if(((_self.s.currentBatchSize + 1) >= _self.s.maxWriteBatchSize)
+ || ((_self.s.currentBatchSizeBytes + _self.s.currentBatchSizeBytes) >= _self.s.maxBatchSizeBytes)
+ || (_self.s.currentBatch.batchType != docType)) {
+ // Save the batch to the execution stack
+ _self.s.batches.push(_self.s.currentBatch);
+
+ // Create a new batch
+ _self.s.currentBatch = new Batch(docType, _self.s.currentIndex);
+
+ // Reset the current size trackers
+ _self.s.currentBatchSize = 0;
+ _self.s.currentBatchSizeBytes = 0;
+ } else {
+ // Update current batch size
+ _self.s.currentBatchSize = _self.s.currentBatchSize + 1;
+ _self.s.currentBatchSizeBytes = _self.s.currentBatchSizeBytes + bsonSize;
+ }
+
+ if(docType == common.INSERT) {
+ _self.s.bulkResult.insertedIds.push({index: _self.s.currentIndex, _id: document._id});
+ }
+
+ // We have an array of documents
+ if(Array.isArray(document)) {
+ throw toError("operation passed in cannot be an Array");
+ } else {
+ _self.s.currentBatch.originalIndexes.push(_self.s.currentIndex);
+ _self.s.currentBatch.operations.push(document)
+ _self.s.currentIndex = _self.s.currentIndex + 1;
+ }
+
+ // Return self
+ return _self;
+}
+
+/**
+ * Create a new OrderedBulkOperation instance (INTERNAL TYPE, do not instantiate directly)
+ * @class
+ * @property {number} length Get the number of operations in the bulk.
+ * @return {OrderedBulkOperation} a OrderedBulkOperation instance.
+ */
+function OrderedBulkOperation(topology, collection, options) {
+ options = options == null ? {} : options;
+ // TODO Bring from driver information in isMaster
+ var self = this;
+ var executed = false;
+
+ // Current item
+ var currentOp = null;
+
+ // Handle to the bson serializer, used to calculate running sizes
+ var bson = topology.bson;
+
+ // Namespace for the operation
+ var namespace = collection.collectionName;
+
+ // Set max byte size
+ var maxBatchSizeBytes = topology.isMasterDoc.maxBsonObjectSize;
+ var maxWriteBatchSize = topology.isMasterDoc.maxWriteBatchSize || 1000;
+
+ // Get the capabilities
+ var capabilities = topology.capabilities();
+
+ // Get the write concern
+ var writeConcern = common.writeConcern(shallowClone(options), collection, options);
+
+ // Current batch
+ var currentBatch = null;
+ var currentIndex = 0;
+ var currentBatchSize = 0;
+ var currentBatchSizeBytes = 0;
+ var batches = [];
+
+ // Final results
+ var bulkResult = {
+ ok: 1
+ , writeErrors: []
+ , writeConcernErrors: []
+ , insertedIds: []
+ , nInserted: 0
+ , nUpserted: 0
+ , nMatched: 0
+ , nModified: 0
+ , nRemoved: 0
+ , upserted: []
+ };
+
+ // Internal state
+ this.s = {
+ // Final result
+ bulkResult: bulkResult
+ // Current batch state
+ , currentBatch: null
+ , currentIndex: 0
+ , currentBatchSize: 0
+ , currentBatchSizeBytes: 0
+ , batches: []
+ // Write concern
+ , writeConcern: writeConcern
+ // Capabilities
+ , capabilities: capabilities
+ // Max batch size options
+ , maxBatchSizeBytes: maxBatchSizeBytes
+ , maxWriteBatchSize: maxWriteBatchSize
+ // Namespace
+ , namespace: namespace
+ // BSON
+ , bson: bson
+ // Topology
+ , topology: topology
+ // Options
+ , options: options
+ // Current operation
+ , currentOp: currentOp
+ // Executed
+ , executed: executed
+ // Collection
+ , collection: collection
+ }
+}
+
+OrderedBulkOperation.prototype.raw = function(op) {
+ var key = Object.keys(op)[0];
+
+ // Update operations
+ if((op.updateOne && op.updateOne.q)
+ || (op.updateMany && op.updateMany.q)
+ || (op.replaceOne && op.replaceOne.q)) {
+ op[key].multi = op.updateOne || op.replaceOne ? false : true;
+ return addToOperationsList(this, common.UPDATE, op[key]);
+ }
+
+ // Crud spec update format
+ if(op.updateOne || op.updateMany || op.replaceOne) {
+ var multi = op.updateOne || op.replaceOne ? false : true;
+ var operation = {q: op[key].filter, u: op[key].update || op[key].replacement, multi: multi}
+ if(op[key].upsert) operation.upsert = true;
+ return addToOperationsList(this, common.UPDATE, operation);
+ }
+
+ // Remove operations
+ if(op.removeOne || op.removeMany || (op.deleteOne && op.deleteOne.q) || op.deleteMany && op.deleteMany.q) {
+ op[key].limit = op.removeOne ? 1 : 0;
+ return addToOperationsList(this, common.REMOVE, op[key]);
+ }
+
+ // Crud spec delete operations, less efficient
+ if(op.deleteOne || op.deleteMany) {
+ var limit = op.deleteOne ? 1 : 0;
+ var operation = {q: op[key].filter, limit: limit}
+ return addToOperationsList(this, common.REMOVE, operation);
+ }
+
+ // Insert operations
+ if(op.insertOne && op.insertOne.document == null) {
+ if(op.insertOne._id == null) op.insertOne._id = new ObjectID();
+ return addToOperationsList(this, common.INSERT, op.insertOne);
+ } else if(op.insertOne && op.insertOne.document) {
+ if(op.insertOne.document._id == null) op.insertOne.document._id = new ObjectID();
+ return addToOperationsList(this, common.INSERT, op.insertOne.document);
+ }
+
+ if(op.insertMany) {
+ for(var i = 0; i < op.insertMany.length; i++) {
+ if(op.insertMany[i]._id == null) op.insertMany[i]._id = new ObjectID();
+ addToOperationsList(this, common.INSERT, op.insertMany[i]);
+ }
+
+ return;
+ }
+
+ // No valid type of operation
+ throw toError("bulkWrite only supports insertOne, insertMany, updateOne, updateMany, removeOne, removeMany, deleteOne, deleteMany");
+}
+
+/**
+ * Add a single insert document to the bulk operation
+ *
+ * @param {object} doc the document to insert
+ * @throws {MongoError}
+ * @return {OrderedBulkOperation}
+ */
+OrderedBulkOperation.prototype.insert = function(document) {
+ if(document._id == null) document._id = new ObjectID();
+ return addToOperationsList(this, common.INSERT, document);
+}
+
+/**
+ * Initiate a find operation for an update/updateOne/remove/removeOne/replaceOne
+ *
+ * @method
+ * @param {object} selector The selector for the bulk operation.
+ * @throws {MongoError}
+ * @return {FindOperatorsOrdered}
+ */
+OrderedBulkOperation.prototype.find = function(selector) {
+ if (!selector) {
+ throw toError("Bulk find operation must specify a selector");
+ }
+
+ // Save a current selector
+ this.s.currentOp = {
+ selector: selector
+ }
+
+ return new FindOperatorsOrdered(this);
+}
+
+Object.defineProperty(OrderedBulkOperation.prototype, 'length', {
+ enumerable: true,
+ get: function() {
+ return this.s.currentIndex;
+ }
+});
+
+//
+// Execute next write command in a chain
+var executeCommands = function(self, callback) {
+ if(self.s.batches.length == 0) {
+ return callback(null, new BulkWriteResult(self.s.bulkResult));
+ }
+
+ // Ordered execution of the command
+ var batch = self.s.batches.shift();
+
+ var resultHandler = function(err, result) {
+ // If we have and error
+ if(err) err.ok = 0;
+ // Merge the results together
+ var mergeResult = mergeBatchResults(true, batch, self.s.bulkResult, err, result);
+ if(mergeResult != null) {
+ return callback(null, new BulkWriteResult(self.s.bulkResult));
+ }
+
+ // If we are ordered and have errors and they are
+ // not all replication errors terminate the operation
+ if(self.s.bulkResult.writeErrors.length > 0) {
+ return callback(self.s.bulkResult.writeErrors[0], new BulkWriteResult(self.s.bulkResult));
+ }
+
+ // Execute the next command in line
+ executeCommands(self, callback);
+ }
+
+ var finalOptions = {ordered: true}
+ if(self.s.writeConcern != null) {
+ finalOptions.writeConcern = self.s.writeConcern;
+ }
+
+ try {
+ if(batch.batchType == common.INSERT) {
+ self.s.topology.insert(self.s.collection.namespace, batch.operations, finalOptions, resultHandler);
+ } else if(batch.batchType == common.UPDATE) {
+ self.s.topology.update(self.s.collection.namespace, batch.operations, finalOptions, resultHandler);
+ } else if(batch.batchType == common.REMOVE) {
+ self.s.topology.remove(self.s.collection.namespace, batch.operations, finalOptions, resultHandler);
+ }
+ } catch(err) {
+ // Force top level error
+ err.ok = 0;
+ // Merge top level error and return
+ callback(null, mergeBatchResults(false, batch, self.s.bulkResult, err, null));
+ }
+}
+
+/**
+ * The callback format for results
+ * @callback OrderedBulkOperation~resultCallback
+ * @param {MongoError} error An error instance representing the error during the execution.
+ * @param {BulkWriteResult} result The bulk write result.
+ */
+
+/**
+ * Execute the ordered bulk operation
+ *
+ * @method
+ * @param {object} [options=null] Optional settings.
+ * @param {(number|string)} [options.w=null] The write concern.
+ * @param {number} [options.wtimeout=null] The write concern timeout.
+ * @param {boolean} [options.j=false] Specify a journal write concern.
+ * @param {boolean} [options.fsync=false] Specify a file sync write concern.
+ * @param {OrderedBulkOperation~resultCallback} callback The result callback
+ * @throws {MongoError}
+ * @return {null}
+ */
+OrderedBulkOperation.prototype.execute = function(_writeConcern, callback) {
+ if(this.s.executed) throw new toError("batch cannot be re-executed");
+ if(typeof _writeConcern == 'function') {
+ callback = _writeConcern;
+ } else {
+ this.s.writeConcern = _writeConcern;
+ }
+
+ // If we have current batch
+ if(this.s.currentBatch) this.s.batches.push(this.s.currentBatch);
+
+ // If we have no operations in the bulk raise an error
+ if(this.s.batches.length == 0) {
+ throw toError("Invalid Operation, No operations in bulk");
+ }
+
+ // Execute the commands
+ return executeCommands(this, callback);
+}
+
+/**
+ * Returns an unordered batch object
+ * @ignore
+ */
+var initializeOrderedBulkOp = function(topology, collection, options) {
+ return new OrderedBulkOperation(topology, collection, options);
+}
+
+module.exports = initializeOrderedBulkOp;
diff --git a/server/node_modules/mongodb/lib/bulk/unordered.js b/server/node_modules/mongodb/lib/bulk/unordered.js
new file mode 100755
index 00000000..4f1d8a25
--- /dev/null
+++ b/server/node_modules/mongodb/lib/bulk/unordered.js
@@ -0,0 +1,482 @@
+"use strict";
+
+var common = require('./common')
+ , utils = require('../utils')
+ , toError = require('../utils').toError
+ , f = require('util').format
+ , shallowClone = utils.shallowClone
+ , WriteError = common.WriteError
+ , BulkWriteResult = common.BulkWriteResult
+ , LegacyOp = common.LegacyOp
+ , ObjectID = require('mongodb-core').BSON.ObjectID
+ , Batch = common.Batch
+ , mergeBatchResults = common.mergeBatchResults;
+
+/**
+ * Create a FindOperatorsUnordered instance (INTERNAL TYPE, do not instantiate directly)
+ * @class
+ * @property {number} length Get the number of operations in the bulk.
+ * @return {FindOperatorsUnordered} a FindOperatorsUnordered instance.
+ */
+var FindOperatorsUnordered = function(self) {
+ this.s = self.s;
+}
+
+/**
+ * Add a single update document to the bulk operation
+ *
+ * @method
+ * @param {object} doc update operations
+ * @throws {MongoError}
+ * @return {UnorderedBulkOperation}
+ */
+FindOperatorsUnordered.prototype.update = function(updateDocument) {
+ // Perform upsert
+ var upsert = typeof this.s.currentOp.upsert == 'boolean' ? this.s.currentOp.upsert : false;
+
+ // Establish the update command
+ var document = {
+ q: this.s.currentOp.selector
+ , u: updateDocument
+ , multi: true
+ , upsert: upsert
+ }
+
+ // Clear out current Op
+ this.s.currentOp = null;
+ // Add the update document to the list
+ return addToOperationsList(this, common.UPDATE, document);
+}
+
+/**
+ * Add a single update one document to the bulk operation
+ *
+ * @method
+ * @param {object} doc update operations
+ * @throws {MongoError}
+ * @return {UnorderedBulkOperation}
+ */
+FindOperatorsUnordered.prototype.updateOne = function(updateDocument) {
+ // Perform upsert
+ var upsert = typeof this.s.currentOp.upsert == 'boolean' ? this.s.currentOp.upsert : false;
+
+ // Establish the update command
+ var document = {
+ q: this.s.currentOp.selector
+ , u: updateDocument
+ , multi: false
+ , upsert: upsert
+ }
+
+ // Clear out current Op
+ this.s.currentOp = null;
+ // Add the update document to the list
+ return addToOperationsList(this, common.UPDATE, document);
+}
+
+/**
+ * Add a replace one operation to the bulk operation
+ *
+ * @method
+ * @param {object} doc the new document to replace the existing one with
+ * @throws {MongoError}
+ * @return {UnorderedBulkOperation}
+ */
+FindOperatorsUnordered.prototype.replaceOne = function(updateDocument) {
+ this.updateOne(updateDocument);
+}
+
+/**
+ * Upsert modifier for update bulk operation
+ *
+ * @method
+ * @throws {MongoError}
+ * @return {UnorderedBulkOperation}
+ */
+FindOperatorsUnordered.prototype.upsert = function() {
+ this.s.currentOp.upsert = true;
+ return this;
+}
+
+/**
+ * Add a remove one operation to the bulk operation
+ *
+ * @method
+ * @throws {MongoError}
+ * @return {UnorderedBulkOperation}
+ */
+FindOperatorsUnordered.prototype.removeOne = function() {
+ // Establish the update command
+ var document = {
+ q: this.s.currentOp.selector
+ , limit: 1
+ }
+
+ // Clear out current Op
+ this.s.currentOp = null;
+ // Add the remove document to the list
+ return addToOperationsList(this, common.REMOVE, document);
+}
+
+/**
+ * Add a remove operation to the bulk operation
+ *
+ * @method
+ * @throws {MongoError}
+ * @return {UnorderedBulkOperation}
+ */
+FindOperatorsUnordered.prototype.remove = function() {
+ // Establish the update command
+ var document = {
+ q: this.s.currentOp.selector
+ , limit: 0
+ }
+
+ // Clear out current Op
+ this.s.currentOp = null;
+ // Add the remove document to the list
+ return addToOperationsList(this, common.REMOVE, document);
+}
+
+//
+// Add to the operations list
+//
+var addToOperationsList = function(_self, docType, document) {
+ // Get the bsonSize
+ var bsonSize = _self.s.bson.calculateObjectSize(document, false);
+ // Throw error if the doc is bigger than the max BSON size
+ if(bsonSize >= _self.s.maxBatchSizeBytes) throw toError("document is larger than the maximum size " + _self.s.maxBatchSizeBytes);
+ // Holds the current batch
+ _self.s.currentBatch = null;
+ // Get the right type of batch
+ if(docType == common.INSERT) {
+ _self.s.currentBatch = _self.s.currentInsertBatch;
+ } else if(docType == common.UPDATE) {
+ _self.s.currentBatch = _self.s.currentUpdateBatch;
+ } else if(docType == common.REMOVE) {
+ _self.s.currentBatch = _self.s.currentRemoveBatch;
+ }
+
+ // Create a new batch object if we don't have a current one
+ if(_self.s.currentBatch == null) _self.s.currentBatch = new Batch(docType, _self.s.currentIndex);
+
+ // Check if we need to create a new batch
+ if(((_self.s.currentBatch.size + 1) >= _self.s.maxWriteBatchSize)
+ || ((_self.s.currentBatch.sizeBytes + bsonSize) >= _self.s.maxBatchSizeBytes)
+ || (_self.s.currentBatch.batchType != docType)) {
+ // Save the batch to the execution stack
+ _self.s.batches.push(_self.s.currentBatch);
+
+ // Create a new batch
+ _self.s.currentBatch = new Batch(docType, _self.s.currentIndex);
+ }
+
+ // We have an array of documents
+ if(Array.isArray(document)) {
+ throw toError("operation passed in cannot be an Array");
+ } else {
+ _self.s.currentBatch.operations.push(document);
+ _self.s.currentBatch.originalIndexes.push(_self.s.currentIndex);
+ _self.s.currentIndex = _self.s.currentIndex + 1;
+ }
+
+ // Save back the current Batch to the right type
+ if(docType == common.INSERT) {
+ _self.s.currentInsertBatch = _self.s.currentBatch;
+ _self.s.bulkResult.insertedIds.push({index: _self.s.currentIndex, _id: document._id});
+ } else if(docType == common.UPDATE) {
+ _self.s.currentUpdateBatch = _self.s.currentBatch;
+ } else if(docType == common.REMOVE) {
+ _self.s.currentRemoveBatch = _self.s.currentBatch;
+ }
+
+ // Update current batch size
+ _self.s.currentBatch.size = _self.s.currentBatch.size + 1;
+ _self.s.currentBatch.sizeBytes = _self.s.currentBatch.sizeBytes + bsonSize;
+
+ // Return self
+ return _self;
+}
+
+/**
+ * Create a new UnorderedBulkOperation instance (INTERNAL TYPE, do not instantiate directly)
+ * @class
+ * @return {UnorderedBulkOperation} a UnorderedBulkOperation instance.
+ */
+var UnorderedBulkOperation = function(topology, collection, options) {
+ options = options == null ? {} : options;
+
+ // Contains reference to self
+ var self = this;
+ // Get the namesspace for the write operations
+ var namespace = collection.collectionName;
+ // Used to mark operation as executed
+ var executed = false;
+
+ // Current item
+ // var currentBatch = null;
+ var currentOp = null;
+ var currentIndex = 0;
+ var batches = [];
+
+ // The current Batches for the different operations
+ var currentInsertBatch = null;
+ var currentUpdateBatch = null;
+ var currentRemoveBatch = null;
+
+ // Handle to the bson serializer, used to calculate running sizes
+ var bson = topology.bson;
+
+ // Get the capabilities
+ var capabilities = topology.capabilities();
+
+ // Set max byte size
+ var maxBatchSizeBytes = topology.isMasterDoc.maxBsonObjectSize;
+ var maxWriteBatchSize = topology.isMasterDoc.maxWriteBatchSize || 1000;
+
+ // Get the write concern
+ var writeConcern = common.writeConcern(shallowClone(options), collection, options);
+
+ // Final results
+ var bulkResult = {
+ ok: 1
+ , writeErrors: []
+ , writeConcernErrors: []
+ , insertedIds: []
+ , nInserted: 0
+ , nUpserted: 0
+ , nMatched: 0
+ , nModified: 0
+ , nRemoved: 0
+ , upserted: []
+ };
+
+ // Internal state
+ this.s = {
+ // Final result
+ bulkResult: bulkResult
+ // Current batch state
+ , currentInsertBatch: null
+ , currentUpdateBatch: null
+ , currentRemoveBatch: null
+ , currentBatch: null
+ , currentIndex: 0
+ , batches: []
+ // Write concern
+ , writeConcern: writeConcern
+ // Capabilities
+ , capabilities: capabilities
+ // Max batch size options
+ , maxBatchSizeBytes: maxBatchSizeBytes
+ , maxWriteBatchSize: maxWriteBatchSize
+ // Namespace
+ , namespace: namespace
+ // BSON
+ , bson: bson
+ // Topology
+ , topology: topology
+ // Options
+ , options: options
+ // Current operation
+ , currentOp: currentOp
+ // Executed
+ , executed: executed
+ // Collection
+ , collection: collection
+ }
+}
+
+/**
+ * Add a single insert document to the bulk operation
+ *
+ * @param {object} doc the document to insert
+ * @throws {MongoError}
+ * @return {UnorderedBulkOperation}
+ */
+UnorderedBulkOperation.prototype.insert = function(document) {
+ if(document._id == null) document._id = new ObjectID();
+ return addToOperationsList(this, common.INSERT, document);
+}
+
+/**
+ * Initiate a find operation for an update/updateOne/remove/removeOne/replaceOne
+ *
+ * @method
+ * @param {object} selector The selector for the bulk operation.
+ * @throws {MongoError}
+ * @return {FindOperatorsUnordered}
+ */
+UnorderedBulkOperation.prototype.find = function(selector) {
+ if (!selector) {
+ throw toError("Bulk find operation must specify a selector");
+ }
+
+ // Save a current selector
+ this.s.currentOp = {
+ selector: selector
+ }
+
+ return new FindOperatorsUnordered(this);
+}
+
+Object.defineProperty(UnorderedBulkOperation.prototype, 'length', {
+ enumerable: true,
+ get: function() {
+ return this.s.currentIndex;
+ }
+});
+
+UnorderedBulkOperation.prototype.raw = function(op) {
+ var key = Object.keys(op)[0];
+
+ // Update operations
+ if((op.updateOne && op.updateOne.q)
+ || (op.updateMany && op.updateMany.q)
+ || (op.replaceOne && op.replaceOne.q)) {
+ op[key].multi = op.updateOne || op.replaceOne ? false : true;
+ return addToOperationsList(this, common.UPDATE, op[key]);
+ }
+
+ // Crud spec update format
+ if(op.updateOne || op.updateMany || op.replaceOne) {
+ var multi = op.updateOne || op.replaceOne ? false : true;
+ var operation = {q: op[key].filter, u: op[key].update || op[key].replacement, multi: multi}
+ if(op[key].upsert) operation.upsert = true;
+ return addToOperationsList(this, common.UPDATE, operation);
+ }
+
+ // Remove operations
+ if(op.removeOne || op.removeMany || (op.deleteOne && op.deleteOne.q) || op.deleteMany && op.deleteMany.q) {
+ op[key].limit = op.removeOne ? 1 : 0;
+ return addToOperationsList(this, common.REMOVE, op[key]);
+ }
+
+ // Crud spec delete operations, less efficient
+ if(op.deleteOne || op.deleteMany) {
+ var limit = op.deleteOne ? 1 : 0;
+ var operation = {q: op[key].filter, limit: limit}
+ return addToOperationsList(this, common.REMOVE, operation);
+ }
+
+ // Insert operations
+ if(op.insertOne && op.insertOne.document == null) {
+ if(op.insertOne._id == null) op.insertOne._id = new ObjectID();
+ return addToOperationsList(this, common.INSERT, op.insertOne);
+ } else if(op.insertOne && op.insertOne.document) {
+ if(op.insertOne.document._id == null) op.insertOne.document._id = new ObjectID();
+ return addToOperationsList(this, common.INSERT, op.insertOne.document);
+ }
+
+ if(op.insertMany) {
+ for(var i = 0; i < op.insertMany.length; i++) {
+ addToOperationsList(this, common.INSERT, op.insertMany[i]);
+ }
+
+ return;
+ }
+
+ // No valid type of operation
+ throw toError("bulkWrite only supports insertOne, insertMany, updateOne, updateMany, removeOne, removeMany, deleteOne, deleteMany");
+}
+
+//
+// Execute the command
+var executeBatch = function(self, batch, callback) {
+ var finalOptions = {ordered: false}
+ if(self.s.writeConcern != null) {
+ finalOptions.writeConcern = self.s.writeConcern;
+ }
+
+ var resultHandler = function(err, result) {
+ // If we have and error
+ if(err) err.ok = 0;
+ callback(null, mergeBatchResults(false, batch, self.s.bulkResult, err, result));
+ }
+
+ try {
+ if(batch.batchType == common.INSERT) {
+ self.s.topology.insert(self.s.collection.namespace, batch.operations, finalOptions, resultHandler);
+ } else if(batch.batchType == common.UPDATE) {
+ self.s.topology.update(self.s.collection.namespace, batch.operations, finalOptions, resultHandler);
+ } else if(batch.batchType == common.REMOVE) {
+ self.s.topology.remove(self.s.collection.namespace, batch.operations, finalOptions, resultHandler);
+ }
+ } catch(err) {
+ // Force top level error
+ err.ok = 0;
+ // Merge top level error and return
+ callback(null, mergeBatchResults(false, batch, self.s.bulkResult, err, null));
+ }
+}
+
+//
+// Execute all the commands
+var executeBatches = function(self, callback) {
+ var numberOfCommandsToExecute = self.s.batches.length;
+ // Execute over all the batches
+ for(var i = 0; i < self.s.batches.length; i++) {
+ executeBatch(self, self.s.batches[i], function(err, result) {
+ numberOfCommandsToExecute = numberOfCommandsToExecute - 1;
+
+ // Execute
+ if(numberOfCommandsToExecute == 0) {
+ var error = self.s.bulkResult.writeErrors.length > 0 ? self.s.bulkResult.writeErrors[0] : null;
+ callback(error, new BulkWriteResult(self.s.bulkResult));
+ }
+ });
+ }
+}
+
+/**
+ * The callback format for results
+ * @callback UnorderedBulkOperation~resultCallback
+ * @param {MongoError} error An error instance representing the error during the execution.
+ * @param {BulkWriteResult} result The bulk write result.
+ */
+
+/**
+ * Execute the ordered bulk operation
+ *
+ * @method
+ * @param {object} [options=null] Optional settings.
+ * @param {(number|string)} [options.w=null] The write concern.
+ * @param {number} [options.wtimeout=null] The write concern timeout.
+ * @param {boolean} [options.j=false] Specify a journal write concern.
+ * @param {boolean} [options.fsync=false] Specify a file sync write concern.
+ * @param {UnorderedBulkOperation~resultCallback} callback The result callback
+ * @throws {MongoError}
+ * @return {null}
+ */
+UnorderedBulkOperation.prototype.execute = function(_writeConcern, callback) {
+ if(this.s.executed) throw toError("batch cannot be re-executed");
+ if(typeof _writeConcern == 'function') {
+ callback = _writeConcern;
+ } else {
+ this.s.writeConcern = _writeConcern;
+ }
+
+ // If we have current batch
+ if(this.s.currentInsertBatch) this.s.batches.push(this.s.currentInsertBatch);
+ if(this.s.currentUpdateBatch) this.s.batches.push(this.s.currentUpdateBatch);
+ if(this.s.currentRemoveBatch) this.s.batches.push(this.s.currentRemoveBatch);
+
+ // If we have no operations in the bulk raise an error
+ if(this.s.batches.length == 0) {
+ throw toError("Invalid Operation, No operations in bulk");
+ }
+
+ // Execute batches
+ return executeBatches(this, function(err, result) {
+ callback(err, result);
+ });
+}
+
+/**
+ * Returns an unordered batch object
+ * @ignore
+ */
+var initializeUnorderedBulkOp = function(topology, collection, options) {
+ return new UnorderedBulkOperation(topology, collection, options);
+}
+
+module.exports = initializeUnorderedBulkOp;
diff --git a/server/node_modules/mongodb/lib/collection.js b/server/node_modules/mongodb/lib/collection.js
new file mode 100755
index 00000000..0e1b585e
--- /dev/null
+++ b/server/node_modules/mongodb/lib/collection.js
@@ -0,0 +1,2079 @@
+"use strict";
+
+var checkCollectionName = require('./utils').checkCollectionName
+ , ObjectID = require('mongodb-core').BSON.ObjectID
+ , Long = require('mongodb-core').BSON.Long
+ , Code = require('mongodb-core').BSON.Code
+ , f = require('util').format
+ , AggregationCursor = require('./aggregation_cursor')
+ , MongoError = require('mongodb-core').MongoError
+ , shallowClone = require('./utils').shallowClone
+ , isObject = require('./utils').isObject
+ , toError = require('./utils').toError
+ , normalizeHintField = require('./utils').normalizeHintField
+ , handleCallback = require('./utils').handleCallback
+ , decorateCommand = require('./utils').decorateCommand
+ , formattedOrderClause = require('./utils').formattedOrderClause
+ , ReadPreference = require('./read_preference')
+ , CoreReadPreference = require('mongodb-core').ReadPreference
+ , CommandCursor = require('./command_cursor')
+ , Cursor = require('./cursor')
+ , unordered = require('./bulk/unordered')
+ , ordered = require('./bulk/ordered');
+
+/**
+ * @fileOverview The **Collection** class is an internal class that embodies a MongoDB collection
+ * allowing for insert/update/remove/find and other command operation on that MongoDB collection.
+ *
+ * **COLLECTION Cannot directly be instantiated**
+ * @example
+ * var MongoClient = require('mongodb').MongoClient,
+ * test = require('assert');
+ * // Connection url
+ * var url = 'mongodb://localhost:27017/test';
+ * // Connect using MongoClient
+ * MongoClient.connect(url, function(err, db) {
+ * // Create a collection we want to drop later
+ * var col = db.collection('createIndexExample1');
+ * // Show that duplicate records got dropped
+ * col.find({}).toArray(function(err, items) {
+ * test.equal(null, err);
+ * test.equal(4, items.length);
+ * db.close();
+ * });
+ * });
+ */
+
+/**
+ * Create a new Collection instance (INTERNAL TYPE, do not instantiate directly)
+ * @class
+ * @property {string} collectionName Get the collection name.
+ * @property {string} namespace Get the full collection namespace.
+ * @property {object} writeConcern The current write concern values.
+ * @property {object} hint Get current index hint for collection.
+ * @return {Collection} a Collection instance.
+ */
+var Collection = function(db, topology, dbName, name, pkFactory, options) {
+ checkCollectionName(name);
+ var self = this;
+ // Unpack variables
+ var internalHint = null;
+ var opts = options != null && ('object' === typeof options) ? options : {};
+ var slaveOk = options == null || options.slaveOk == null ? db.slaveOk : options.slaveOk;
+ var serializeFunctions = options == null || options.serializeFunctions == null ? db.serializeFunctions : options.serializeFunctions;
+ var raw = options == null || options.raw == null ? db.raw : options.raw;
+ var readPreference = null;
+ var collectionHint = null;
+ var namespace = f("%s.%s", dbName, name);
+
+ // Assign the right collection level readPreference
+ if(options && options.readPreference) {
+ readPreference = options.readPreference;
+ } else if(db.options.readPreference) {
+ readPreference = db.options.readPreference;
+ }
+
+ // Set custom primary key factory if provided
+ pkFactory = pkFactory == null
+ ? ObjectID
+ : pkFactory;
+
+ // Internal state
+ this.s = {
+ // Set custom primary key factory if provided
+ pkFactory: pkFactory
+ // Db
+ , db: db
+ // Topology
+ , topology: topology
+ // dbName
+ , dbName: dbName
+ // Options
+ , options: options
+ // Namespace
+ , namespace: namespace
+ // Read preference
+ , readPreference: readPreference
+ // Raw
+ , raw: raw
+ // SlaveOK
+ , slaveOk: slaveOk
+ // Serialize functions
+ , serializeFunctions: serializeFunctions
+ // internalHint
+ , internalHint: internalHint
+ // collectionHint
+ , collectionHint: collectionHint
+ // Name
+ , name: name
+ }
+}
+
+Object.defineProperty(Collection.prototype, 'collectionName', {
+ enumerable: true, get: function() { return this.s.name; }
+});
+
+Object.defineProperty(Collection.prototype, 'namespace', {
+ enumerable: true, get: function() { return this.s.namespace; }
+});
+
+Object.defineProperty(Collection.prototype, 'writeConcern', {
+ enumerable:true,
+ get: function() {
+ var ops = {};
+ if(this.s.options.w != null) ops.w = this.s.options.w;
+ if(this.s.options.j != null) ops.j = this.s.options.j;
+ if(this.s.options.fsync != null) ops.fsync = this.s.options.fsync;
+ if(this.s.options.wtimeout != null) ops.wtimeout = this.s.options.wtimeout;
+ return ops;
+ }
+});
+
+/**
+ * @ignore
+ */
+Object.defineProperty(Collection.prototype, "hint", {
+ enumerable: true
+ , get: function () { return this.s.collectionHint; }
+ , set: function (v) { this.s.collectionHint = normalizeHintField(v); }
+});
+
+/**
+ * Creates a cursor for a query that can be used to iterate over results from MongoDB
+ * @method
+ * @param {object} query The cursor query object.
+ * @throws {MongoError}
+ * @return {Cursor}
+ */
+Collection.prototype.find = function() {
+ var options
+ , args = Array.prototype.slice.call(arguments, 0)
+ , has_callback = typeof args[args.length - 1] === 'function'
+ , has_weird_callback = typeof args[0] === 'function'
+ , callback = has_callback ? args.pop() : (has_weird_callback ? args.shift() : null)
+ , len = args.length
+ , selector = len >= 1 ? args[0] : {}
+ , fields = len >= 2 ? args[1] : undefined;
+
+ if(len === 1 && has_weird_callback) {
+ // backwards compat for callback?, options case
+ selector = {};
+ options = args[0];
+ }
+
+ if(len === 2 && !Array.isArray(fields)) {
+ var fieldKeys = Object.keys(fields);
+ var is_option = false;
+
+ for(var i = 0; i < fieldKeys.length; i++) {
+ if(testForFields[fieldKeys[i]] != null) {
+ is_option = true;
+ break;
+ }
+ }
+
+ if(is_option) {
+ options = fields;
+ fields = undefined;
+ } else {
+ options = {};
+ }
+ } else if(len === 2 && Array.isArray(fields) && !Array.isArray(fields[0])) {
+ var newFields = {};
+ // Rewrite the array
+ for(var i = 0; i < fields.length; i++) {
+ newFields[fields[i]] = 1;
+ }
+ // Set the fields
+ fields = newFields;
+ }
+
+ if(3 === len) {
+ options = args[2];
+ }
+
+ // Ensure selector is not null
+ selector = selector == null ? {} : selector;
+ // Validate correctness off the selector
+ var object = selector;
+ if(Buffer.isBuffer(object)) {
+ var object_size = object[0] | object[1] << 8 | object[2] << 16 | object[3] << 24;
+ if(object_size != object.length) {
+ var error = new Error("query selector raw message size does not match message header size [" + object.length + "] != [" + object_size + "]");
+ error.name = 'MongoError';
+ throw error;
+ }
+ }
+
+ // Validate correctness of the field selector
+ var object = fields;
+ if(Buffer.isBuffer(object)) {
+ var object_size = object[0] | object[1] << 8 | object[2] << 16 | object[3] << 24;
+ if(object_size != object.length) {
+ var error = new Error("query fields raw message size does not match message header size [" + object.length + "] != [" + object_size + "]");
+ error.name = 'MongoError';
+ throw error;
+ }
+ }
+
+ // Check special case where we are using an objectId
+ if(selector instanceof ObjectID || (selector != null && selector._bsontype == 'ObjectID')) {
+ selector = {_id:selector};
+ }
+
+ // If it's a serialized fields field we need to just let it through
+ // user be warned it better be good
+ if(options && options.fields && !(Buffer.isBuffer(options.fields))) {
+ fields = {};
+
+ if(Array.isArray(options.fields)) {
+ if(!options.fields.length) {
+ fields['_id'] = 1;
+ } else {
+ for (var i = 0, l = options.fields.length; i < l; i++) {
+ fields[options.fields[i]] = 1;
+ }
+ }
+ } else {
+ fields = options.fields;
+ }
+ }
+
+ if (!options) options = {};
+
+ var newOptions = {};
+ // Make a shallow copy of options
+ for (var key in options) {
+ newOptions[key] = options[key];
+ }
+
+ // Unpack options
+ newOptions.skip = len > 3 ? args[2] : options.skip ? options.skip : 0;
+ newOptions.limit = len > 3 ? args[3] : options.limit ? options.limit : 0;
+ newOptions.raw = options.raw != null && typeof options.raw === 'boolean' ? options.raw : this.s.raw;
+ newOptions.hint = options.hint != null ? normalizeHintField(options.hint) : this.s.collectionHint;
+ newOptions.timeout = len == 5 ? args[4] : typeof options.timeout === 'undefined' ? undefined : options.timeout;
+ // // If we have overridden slaveOk otherwise use the default db setting
+ newOptions.slaveOk = options.slaveOk != null ? options.slaveOk : this.s.db.slaveOk;
+
+ // Add read preference if needed
+ newOptions = getReadPreference(this, newOptions, this.s.db, this);
+ // Set slave ok to true if read preference different from primary
+ if(newOptions.readPreference != null
+ && (newOptions.readPreference != 'primary' || newOptions.readPreference.mode != 'primary')) {
+ newOptions.slaveOk = true;
+ }
+
+ // Ensure the query is an object
+ if(selector != null && typeof selector != 'object') {
+ throw new MongoError("query selector must be an object");
+ }
+
+ // Build the find command
+ var findCommand = {
+ find: this.s.namespace
+ , limit: newOptions.limit
+ , skip: newOptions.skip
+ , query: selector
+ }
+
+ // Ensure we use the right await data option
+ if(typeof newOptions.awaitdata == 'boolean') {
+ newOptions.awaitData = newOptions.awaitdata
+ };
+
+ // Translate to new command option noCursorTimeout
+ if(typeof newOptions.timeout == 'boolean') newOptions.noCursorTimeout = newOptions.timeout;
+
+ // Merge in options to command
+ for(var name in newOptions) {
+ if(newOptions[name] != null) findCommand[name] = newOptions[name];
+ }
+
+ // Format the fields
+ var formatFields = function(fields) {
+ var object = {};
+ if(Array.isArray(fields)) {
+ for(var i = 0; i < fields.length; i++) {
+ if(Array.isArray(fields[i])) {
+ object[fields[i][0]] = fields[i][1];
+ } else {
+ object[fields[i][0]] = 1;
+ }
+ }
+ } else {
+ object = fields;
+ }
+
+ return object;
+ }
+
+ // Special treatment for the fields selector
+ if(fields) findCommand.fields = formatFields(fields);
+
+ // Add db object to the new options
+ newOptions.db = this.s.db;
+
+ // Set raw if available at collection level
+ if(newOptions.raw == null && this.s.raw) newOptions.raw = this.s.raw;
+
+ // Sort options
+ if(findCommand.sort)
+ findCommand.sort = formattedOrderClause(findCommand.sort);
+
+ // Create the cursor
+ if(typeof callback == 'function') return handleCallback(callback, null, this.s.topology.cursor(this.s.namespace, findCommand, newOptions));
+ return this.s.topology.cursor(this.s.namespace, findCommand, newOptions);
+}
+
+/**
+ * Inserts a single document into MongoDB.
+ * @method
+ * @param {object} doc Document to insert.
+ * @param {object} [options=null] Optional settings.
+ * @param {(number|string)} [options.w=null] The write concern.
+ * @param {number} [options.wtimeout=null] The write concern timeout.
+ * @param {boolean} [options.j=false] Specify a journal write concern.
+ * @param {boolean} [options.serializeFunctions=false] Serialize functions on any object.
+ * @param {boolean} [options.forceServerObjectId=false] Force server to assign _id values instead of driver.
+ * @param {Collection~writeOpCallback} callback The command result callback
+ * @return {null}
+ */
+Collection.prototype.insertOne = function(doc, options, callback) {
+ if(typeof options == 'function') callback = options, options = {};
+ if(Array.isArray(doc)) return callback(new MongoError('doc parameter must be an object'));
+ insertDocuments(this, [doc], options, function(err, r) {
+ if(err) return callback(err);
+ r.insertedCount = r.result.n;
+ r.insertedId = doc._id;
+ callback(null, r);
+ });
+}
+
+/**
+ * Inserts an array of documents into MongoDB.
+ * @method
+ * @param {object[]} docs Documents to insert.
+ * @param {object} [options=null] Optional settings.
+ * @param {(number|string)} [options.w=null] The write concern.
+ * @param {number} [options.wtimeout=null] The write concern timeout.
+ * @param {boolean} [options.j=false] Specify a journal write concern.
+ * @param {boolean} [options.serializeFunctions=false] Serialize functions on any object.
+ * @param {boolean} [options.forceServerObjectId=false] Force server to assign _id values instead of driver.
+ * @param {Collection~writeOpCallback} callback The command result callback
+ * @return {null}
+ */
+Collection.prototype.insertMany = function(docs, options, callback) {
+ if(typeof options == 'function') callback = options, options = {};
+ if(!Array.isArray(docs)) return callback(new MongoError('docs parameter must be an array of documents'));
+ insertDocuments(this, docs, options, function(err, r) {
+ if(err) return callback(err);
+ r.insertedCount = r.result.n;
+ var ids = [];
+ for(var i = 0; i < docs.length; i++) {
+ if(docs[i]._id) ids.push(docs[i]._id);
+ }
+ r.insertedIds = ids;
+ callback(null, r);
+ });
+}
+
+/**
+ * @typedef {Object} Collection~BulkWriteOpResult
+ * @property {number} insertedCount Number of documents inserted.
+ * @property {number} matchedCount Number of documents matched for update.
+ * @property {number} modifiedCount Number of documents modified.
+ * @property {number} deletedCount Number of documents deleted.
+ * @property {number} upsertedCount Number of documents upserted.
+ * @property {object} insertedIds Inserted document generated Id's, hash key is the index of the originating operation
+ * @property {object} upsertedIds Upserted document generated Id's, hash key is the index of the originating operation
+ * @property {object} result The command result object.
+ */
+
+/**
+ * The callback format for inserts
+ * @callback Collection~bulkWriteOpCallback
+ * @param {MongoError} error An error instance representing the error during the execution.
+ * @param {Collection~BulkWriteOpResult} result The result object if the command was executed successfully.
+ */
+
+/**
+ * Perform a bulkWrite operation without a fluent API
+ *
+ * Legal operation types are
+ *
+ * { insertOne: { document: { a: 1 } } }
+ * { updateOne: { filter: {a:2}, update: {$set: {a:2}}, upsert:true } }
+ * { updateMany: { filter: {a:2}, update: {$set: {a:2}}, upsert:true } }
+ * { deleteOne: { filter: {c:1} } }
+ * { deleteMany: { filter: {c:1} } }
+ * { replaceOne: { filter: {c:3}, replacement: {c:4}, upsert:true}}]
+ *
+ *
+ * @method
+ * @param {object[]} operations Bulk operations to perform.
+ * @param {object} [options=null] Optional settings.
+ * @param {(number|string)} [options.w=null] The write concern.
+ * @param {number} [options.wtimeout=null] The write concern timeout.
+ * @param {boolean} [options.j=false] Specify a journal write concern.
+ * @param {boolean} [options.serializeFunctions=false] Serialize functions on any object.
+ * @param {Collection~bulkWriteOpCallback} callback The command result callback
+ * @return {null}
+ */
+Collection.prototype.bulkWrite = function(operations, options, callback) {
+ if(typeof options == 'function') callback = options, options = {};
+ if(typeof callback != 'function') throw new MongoError("bulkWrite must have a callback function specified");
+ if(!Array.isArray(operations)) throw new MongoError("operations must be an array of documents");
+ var bulk = options.ordered == true || options.ordered == null ? this.initializeOrderedBulkOp() : this.initializeUnorderedBulkOp();
+
+ // for each op go through and add to the bulk
+ for(var i = 0; i < operations.length; i++) {
+ bulk.raw(operations[i]);
+ }
+
+ // Final options for write concern
+ var finalOptions = writeConcern(shallowClone(options), this.s.db, this, options);
+ var writeCon = finalOptions.writeConcern ? finalOptions.writeConcern : {};
+
+ // Execute the bulk
+ bulk.execute(writeCon, function(err, r) {
+ r.insertedCount = r.nInserted;
+ r.matchedCount = r.nMatched;
+ r.modifiedCount = r.nModified || 0;
+ r.deletedCount = r.nRemoved;
+ r.upsertedCount = r.getUpsertedIds().length;
+ r.upsertedIds = {};
+ r.insertedIds = {};
+
+ // Inserted documents
+ var inserted = r.getInsertedIds();
+ // Map inserted ids
+ for(var i = 0; i < inserted.length; i++) {
+ r.insertedIds[inserted[i].index] = inserted[i]._id;
+ }
+
+ // Upserted documents
+ var upserted = r.getUpsertedIds();
+ // Map upserted ids
+ for(var i = 0; i < upserted.length; i++) {
+ r.upsertedIds[upserted[i].index] = upserted[i]._id;
+ }
+
+ // Return the results
+ callback(null, r);
+ });
+}
+
+var insertDocuments = function(self, docs, options, callback) {
+ if(typeof options == 'function') callback = options, options = {};
+ options = options || {};
+ // Ensure we are operating on an array op docs
+ docs = Array.isArray(docs) ? docs : [docs];
+
+ // Get the write concern options
+ var finalOptions = writeConcern(shallowClone(options), self.s.db, self, options);
+ if(typeof finalOptions.checkKeys != 'boolean') finalOptions.checkKeys = true;
+
+ // If keep going set unordered
+ if(options.keepGoing == true) finalOptions.ordered = false;
+ finalOptions['serializeFunctions'] = options['serializeFunctions'] || self.s.serializeFunctions;
+
+ // Add _id if not specified
+ for(var i = 0; i < docs.length; i++) {
+ if(docs[i]._id == null) docs[i]._id = self.s.pkFactory.createPk();
+ }
+
+ // File inserts
+ self.s.topology.insert(self.s.namespace, docs, finalOptions, function(err, result) {
+ if(callback == null) return;
+ if(err) return handleCallback(callback, err);
+ if(result == null) return handleCallback(callback, null, null);
+ if(result.result.code) return handleCallback(callback, toError(result.result));
+ if(result.result.writeErrors) return handleCallback(callback, toError(result.result.writeErrors[0]));
+ // Add docs to the list
+ result.ops = docs;
+ // Return the results
+ handleCallback(callback, null, result);
+ });
+}
+
+/**
+ * @typedef {Object} Collection~WriteOpResult
+ * @property {object[]} ops All the documents inserted with their new _id values if forceServerObjectId == false.
+ * @property {object} connection The connection object used for the operation.
+ * @property {object} result The command result object.
+ */
+
+/**
+ * The callback format for inserts
+ * @callback Collection~writeOpCallback
+ * @param {MongoError} error An error instance representing the error during the execution.
+ * @param {Collection~WriteOpResult} result The result object if the command was executed successfully.
+ */
+
+/**
+ * Inserts a single document or a an array of documents into MongoDB.
+ * @method
+ * @param {(object|object[])} docs Documents to insert.
+ * @param {object} [options=null] Optional settings.
+ * @param {(number|string)} [options.w=null] The write concern.
+ * @param {number} [options.wtimeout=null] The write concern timeout.
+ * @param {boolean} [options.j=false] Specify a journal write concern.
+ * @param {boolean} [options.serializeFunctions=false] Serialize functions on any object.
+ * @param {boolean} [options.forceServerObjectId=false] Force server to assign _id values instead of driver.
+ * @param {Collection~writeOpCallback} callback The command result callback
+ * @return {null}
+ * @deprecated
+ */
+Collection.prototype.insert = function(docs, options, callback) {
+ return insertDocuments(this, docs, options, callback);
+}
+
+/**
+ * Update a single document on MongoDB
+ * @method
+ * @param {object} filter The Filter used to select the document to update
+ * @param {object} update The update operations to be applied to the document
+ * @param {object} [options=null] Optional settings.
+ * @param {boolean} [options.upsert=false] Update operation is an upsert.
+ * @param {(number|string)} [options.w=null] The write concern.
+ * @param {number} [options.wtimeout=null] The write concern timeout.
+ * @param {boolean} [options.j=false] Specify a journal write concern.
+ * @param {Collection~writeOpCallback} callback The command result callback
+ * @return {null}
+ */
+Collection.prototype.updateOne = function(filter, update, options, callback) {
+ if(typeof options == 'function') callback = options, options = {};
+ options = shallowClone(options)
+ // Set single document update
+ options.multi = false;
+ // Execute update
+ updateDocuments(this, filter, update, options, function(err, r) {
+ if(err) return callback(err);
+ r.matchedCount = r.result.n;
+ r.modifiedCount = r.result.nModified != null ? r.result.nModified : r.result.n;
+ r.upsertedId = Array.isArray(r.result.upserted) && r.result.upserted.length > 0 ? r.result.upserted[0] : null;
+ r.upsertedCount = Array.isArray(r.result.upserted) && r.result.upserted.length ? r.result.upserted.length : 0;
+ callback(null, r);
+ });
+}
+
+/**
+ * Replace a document on MongoDB
+ * @method
+ * @param {object} filter The Filter used to select the document to update
+ * @param {object} doc The Document that replaces the matching document
+ * @param {object} [options=null] Optional settings.
+ * @param {boolean} [options.upsert=false] Update operation is an upsert.
+ * @param {(number|string)} [options.w=null] The write concern.
+ * @param {number} [options.wtimeout=null] The write concern timeout.
+ * @param {boolean} [options.j=false] Specify a journal write concern.
+ * @param {Collection~writeOpCallback} callback The command result callback
+ * @return {null}
+ */
+Collection.prototype.replaceOne = function(filter, update, options, callback) {
+ if(typeof options == 'function') callback = options, options = {};
+ options = shallowClone(options)
+ // Set single document update
+ options.multi = false;
+ // Execute update
+ updateDocuments(this, filter, update, options, function(err, r) {
+ if(err) return callback(err);
+ r.matchedCount = r.result.n;
+ r.modifiedCount = r.result.nModified != null ? r.result.nModified : r.result.n;
+ r.upsertedId = Array.isArray(r.result.upserted) && r.result.upserted.length > 0 ? r.result.upserted[0] : null;
+ r.upsertedCount = Array.isArray(r.result.upserted) && r.result.upserted.length ? r.result.upserted.length : 0;
+ callback(null, r);
+ });
+}
+
+/**
+ * Update multiple documents on MongoDB
+ * @method
+ * @param {object} filter The Filter used to select the document to update
+ * @param {object} update The update operations to be applied to the document
+ * @param {object} [options=null] Optional settings.
+ * @param {boolean} [options.upsert=false] Update operation is an upsert.
+ * @param {(number|string)} [options.w=null] The write concern.
+ * @param {number} [options.wtimeout=null] The write concern timeout.
+ * @param {boolean} [options.j=false] Specify a journal write concern.
+ * @param {Collection~writeOpCallback} callback The command result callback
+ * @return {null}
+ */
+Collection.prototype.updateMany = function(filter, update, options, callback) {
+ if(typeof options == 'function') callback = options, options = {};
+ options = shallowClone(options)
+ // Set single document update
+ options.multi = true;
+ // Execute update
+ updateDocuments(this, filter, update, options, function(err, r) {
+ if(err) return callback(err);
+ r.matchedCount = r.result.n;
+ r.modifiedCount = r.result.nModified != null ? r.result.nModified : r.result.n;
+ r.upsertedId = Array.isArray(r.result.upserted) && r.result.upserted.length > 0 ? r.result.upserted[0] : null;
+ r.upsertedCount = Array.isArray(r.result.upserted) && r.result.upserted.length ? r.result.upserted.length : 0;
+ callback(null, r);
+ });
+}
+
+var updateDocuments = function(self, selector, document, options, callback) {
+ if('function' === typeof options) callback = options, options = null;
+ if(options == null) options = {};
+ if(!('function' === typeof callback)) callback = null;
+
+ // If we are not providing a selector or document throw
+ if(selector == null || typeof selector != 'object') return callback(toError("selector must be a valid JavaScript object"));
+ if(document == null || typeof document != 'object') return callback(toError("document must be a valid JavaScript object"));
+
+ // Get the write concern options
+ var finalOptions = writeConcern(shallowClone(options), self.s.db, self, options);
+
+ // Do we return the actual result document
+ // Either use override on the function, or go back to default on either the collection
+ // level or db
+ finalOptions['serializeFunctions'] = options['serializeFunctions'] || self.s.serializeFunctions;
+
+ // Execute the operation
+ var op = {q: selector, u: document};
+ if(options.upsert) op.upsert = true;
+ if(options.multi) op.multi = true;
+
+ // Update options
+ self.s.topology.update(self.s.namespace, [op], finalOptions, function(err, result) {
+ if(callback == null) return;
+ if(err) return handleCallback(callback, err, null);
+ if(result == null) return handleCallback(callback, null, null);
+ if(result.result.code) return handleCallback(callback, toError(result.result));
+ if(result.result.writeErrors) return handleCallback(callback, toError(result.result.writeErrors[0]));
+ // Return the results
+ handleCallback(callback, null, result);
+ });
+}
+
+/**
+ * Updates documents.
+ * @method
+ * @param {object} selector The selector for the update operation.
+ * @param {object} document The update document.
+ * @param {object} [options=null] Optional settings.
+ * @param {(number|string)} [options.w=null] The write concern.
+ * @param {number} [options.wtimeout=null] The write concern timeout.
+ * @param {boolean} [options.j=false] Specify a journal write concern.
+ * @param {boolean} [options.upsert=false] Update operation is an upsert.
+ * @param {boolean} [options.multi=false] Update one/all documents with operation.
+ * @param {Collection~writeOpCallback} callback The command result callback
+ * @throws {MongoError}
+ * @return {null}
+ * @deprecated
+ */
+Collection.prototype.update = function(selector, document, options, callback) {
+ return updateDocuments(this, selector, document, options, callback);
+}
+
+/**
+ * Delete a document on MongoDB
+ * @method
+ * @param {object} filter The Filter used to select the document to remove
+ * @param {object} [options=null] Optional settings.
+ * @param {(number|string)} [options.w=null] The write concern.
+ * @param {number} [options.wtimeout=null] The write concern timeout.
+ * @param {boolean} [options.j=false] Specify a journal write concern.
+ * @param {Collection~writeOpCallback} callback The command result callback
+ * @return {null}
+ */
+Collection.prototype.deleteOne = function(filter, options, callback) {
+ if(typeof options == 'function') callback = options, options = {};
+ var options = shallowClone(options);
+ options.single = true;
+ removeDocuments(this, filter, options, function(err, r) {
+ if(err) return callback(err);
+ r.deletedCount = r.result.n;
+ callback(null, r);
+ });
+}
+
+Collection.prototype.removeOne = Collection.prototype.deleteOne;
+
+/**
+ * Delete multiple documents on MongoDB
+ * @method
+ * @param {object} filter The Filter used to select the documents to remove
+ * @param {object} [options=null] Optional settings.
+ * @param {(number|string)} [options.w=null] The write concern.
+ * @param {number} [options.wtimeout=null] The write concern timeout.
+ * @param {boolean} [options.j=false] Specify a journal write concern.
+ * @param {Collection~writeOpCallback} callback The command result callback
+ * @return {null}
+ */
+Collection.prototype.deleteMany = function(filter, options, callback) {
+ if(typeof options == 'function') callback = options, options = {};
+ var options = shallowClone(options);
+ options.single = false;
+ removeDocuments(this, filter, options, function(err, r) {
+ if(err) return callback(err);
+ r.deletedCount = r.result.n;
+ callback(null, r);
+ });
+}
+
+Collection.prototype.removeMany = Collection.prototype.deleteMany;
+
+var removeDocuments = function(self, selector, options, callback) {
+ if(typeof options == 'function') {
+ callback = options, options = {};
+ } else if (typeof selector === 'function') {
+ callback = selector;
+ options = {};
+ selector = {};
+ }
+
+ // Create an empty options object if the provided one is null
+ options = options || {};
+
+ // Get the write concern options
+ var finalOptions = writeConcern(shallowClone(options), self.s.db, self, options);
+
+ // If selector is null set empty
+ if(selector == null) selector = {};
+
+ // Build the op
+ var op = {q: selector, limit: 0};
+ if(options.single) op.limit = 1;
+
+ // Execute the remove
+ self.s.topology.remove(self.s.namespace, [op], finalOptions, function(err, result) {
+ if(callback == null) return;
+ if(err) return handleCallback(callback, err, null);
+ if(result == null) return handleCallback(callback, null, null);
+ if(result.result.code) return handleCallback(callback, toError(result.result));
+ if(result.result.writeErrors) return handleCallback(callback, toError(result.result.writeErrors[0]));
+ // Return the results
+ handleCallback(callback, null, result);
+ });
+}
+
+/**
+ * Remove documents.
+ * @method
+ * @param {object} selector The selector for the update operation.
+ * @param {object} [options=null] Optional settings.
+ * @param {(number|string)} [options.w=null] The write concern.
+ * @param {number} [options.wtimeout=null] The write concern timeout.
+ * @param {boolean} [options.j=false] Specify a journal write concern.
+ * @param {boolean} [options.single=false] Removes the first document found.
+ * @param {Collection~writeOpCallback} callback The command result callback
+ * @return {null}
+ * @deprecated
+ */
+Collection.prototype.remove = function(selector, options, callback) {
+ return removeDocuments(this, selector, options, callback);
+}
+
+/**
+ * Save a document. Simple full document replacement function. Not recommended for efficiency, use atomic
+ * operators and update instead for more efficient operations.
+ * @method
+ * @param {object} doc Document to save
+ * @param {object} [options=null] Optional settings.
+ * @param {(number|string)} [options.w=null] The write concern.
+ * @param {number} [options.wtimeout=null] The write concern timeout.
+ * @param {boolean} [options.j=false] Specify a journal write concern.
+ * @param {Collection~writeOpCallback} callback The command result callback
+ * @return {null}
+ */
+Collection.prototype.save = function(doc, options, callback) {
+ if(typeof options == 'function') callback = options, options = {};
+ options = options || {};
+
+ // Get the write concern options
+ var finalOptions = writeConcern(shallowClone(options), this.s.db, this, options);
+ // Establish if we need to perform an insert or update
+ if(doc._id != null) {
+ finalOptions.upsert = true;
+ return updateDocuments(this, {_id: doc._id}, doc, finalOptions, callback);
+ }
+
+ // Insert the document
+ insertDocuments(this, [doc], options, function(err, r) {
+ if(callback == null) return;
+ if(doc == null) return handleCallback(callback, null, null);
+ if(err) return handleCallback(callback, err, null);
+ handleCallback(callback, null, r);
+ });
+}
+
+/**
+ * The callback format for results
+ * @callback Collection~resultCallback
+ * @param {MongoError} error An error instance representing the error during the execution.
+ * @param {object} result The result object if the command was executed successfully.
+ */
+
+/**
+ * Fetches the first document that matches the query
+ * @method
+ * @param {object} query Query for find Operation
+ * @param {object} [options=null] Optional settings.
+ * @param {number} [options.limit=0] Sets the limit of documents returned in the query.
+ * @param {(array|object)} [options.sort=null] Set to sort the documents coming back from the query. Array of indexes, [['a', 1]] etc.
+ * @param {object} [options.fields=null] The fields to return in the query. Object of fields to include or exclude (not both), {'a':1}
+ * @param {number} [options.skip=0] Set to skip N documents ahead in your query (useful for pagination).
+ * @param {Object} [options.hint=null] Tell the query to use specific indexes in the query. Object of indexes to use, {'_id':1}
+ * @param {boolean} [options.explain=false] Explain the query instead of returning the data.
+ * @param {boolean} [options.snapshot=false] Snapshot query.
+ * @param {boolean} [options.timeout=false] Specify if the cursor can timeout.
+ * @param {boolean} [options.tailable=false] Specify if the cursor is tailable.
+ * @param {number} [options.batchSize=0] Set the batchSize for the getMoreCommand when iterating over the query results.
+ * @param {boolean} [options.returnKey=false] Only return the index key.
+ * @param {number} [options.maxScan=null] Limit the number of items to scan.
+ * @param {number} [options.min=null] Set index bounds.
+ * @param {number} [options.max=null] Set index bounds.
+ * @param {boolean} [options.showDiskLoc=false] Show disk location of results.
+ * @param {string} [options.comment=null] You can put a $comment field on a query to make looking in the profiler logs simpler.
+ * @param {boolean} [options.raw=false] Return all BSON documents as Raw Buffer documents.
+ * @param {(ReadPreference|string)} [options.readPreference=null] The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).
+ * @param {boolean} [options.partial=false] Specify if the cursor should return partial results when querying against a sharded system
+ * @param {number} [options.maxTimeMS=null] Number of miliseconds to wait before aborting the query.
+ * @param {Collection~resultCallback} callback The command result callback
+ * @return {null}
+ */
+Collection.prototype.findOne = function() {
+ var self = this;
+ var args = Array.prototype.slice.call(arguments, 0);
+ var callback = args.pop();
+ var cursor = this.find.apply(this, args).limit(-1).batchSize(1);
+
+ // Return the item
+ cursor.next(function(err, item) {
+ if(err != null) return handleCallback(callback, toError(err), null);
+ handleCallback(callback, null, item);
+ });
+}
+
+/**
+ * The callback format for the collection method, must be used if strict is specified
+ * @callback Collection~collectionResultCallback
+ * @param {MongoError} error An error instance representing the error during the execution.
+ * @param {Collection} collection The collection instance.
+ */
+
+/**
+ * Rename the collection.
+ *
+ * @method
+ * @param {string} newName New name of of the collection.
+ * @param {object} [options=null] Optional settings.
+ * @param {boolean} [options.dropTarget=false] Drop the target name collection if it previously exists.
+ * @param {Collection~collectionResultCallback} callback The results callback
+ * @return {null}
+ */
+Collection.prototype.rename = function(newName, opt, callback) {
+ var self = this;
+ if(typeof opt == 'function') callback = opt, opt = {};
+ // Check the collection name
+ checkCollectionName(newName);
+ // Build the command
+ var renameCollection = f("%s.%s", this.s.dbName, this.s.name);
+ var toCollection = f("%s.%s", this.s.dbName, newName);
+ var dropTarget = typeof opt.dropTarget == 'boolean' ? opt.dropTarget : false;
+ var cmd = {'renameCollection':renameCollection, 'to':toCollection, 'dropTarget':dropTarget};
+
+ // Execute against admin
+ self.s.db.admin().command(cmd, opt, function(err, doc) {
+ if(err) return handleCallback(callback, err, null);
+ // We have an error
+ if(doc.errmsg) return handleCallback(callback, toError(doc), null);
+ try {
+ return handleCallback(callback, null, new Collection(self.s.db, self.s.topology, self.s.dbName, newName, self.s.pkFactory, self.s.options));
+ } catch(err) {
+ return handleCallback(callback, toError(err), null);
+ }
+ });
+}
+
+/**
+ * Drop the collection from the database, removing it permanently. New accesses will create a new collection.
+ *
+ * @method
+ * @param {Collection~resultCallback} callback The results callback
+ * @return {null}
+ */
+Collection.prototype.drop = function(callback) {
+ this.s.db.dropCollection(this.s.name, callback);
+}
+
+/**
+ * Returns the options of the collection.
+ *
+ * @method
+ * @param {Collection~resultCallback} callback The results callback
+ * @return {null}
+ */
+Collection.prototype.options = function(callback) {
+ var self = this;
+ this.s.db.listCollections({name: this.s.name}).toArray(function(err, collections) {
+ if(err) return handleCallback(callback, err);
+ if(collections.length == 0) return handleCallback(callback, new MongoError(f("collection %s not found", self.s.namespace)));
+ handleCallback(callback, err, collections[0].options || null);
+ });
+}
+
+/**
+ * Returns if the collection is a capped collection
+ *
+ * @method
+ * @param {Collection~resultCallback} callback The results callback
+ * @return {null}
+ */
+Collection.prototype.isCapped = function(callback) {
+ this.options(function(err, document) {
+ if(err) return handleCallback(callback, err);
+ handleCallback(callback, null, document && document.capped);
+ });
+}
+
+/**
+ * Creates an index on the db and collection collection.
+ * @method
+ * @param {(string|object)} fieldOrSpec Defines the index.
+ * @param {object} [options=null] Optional settings.
+ * @param {(number|string)} [options.w=null] The write concern.
+ * @param {number} [options.wtimeout=null] The write concern timeout.
+ * @param {boolean} [options.j=false] Specify a journal write concern.
+ * @param {boolean} [options.unique=false] Creates an unique index.
+ * @param {boolean} [options.sparse=false] Creates a sparse index.
+ * @param {boolean} [options.background=false] Creates the index in the background, yielding whenever possible.
+ * @param {boolean} [options.dropDups=false] A unique index cannot be created on a key that has pre-existing duplicate values. If you would like to create the index anyway, keeping the first document the database indexes and deleting all subsequent documents that have duplicate value
+ * @param {number} [options.min=null] For geospatial indexes set the lower bound for the co-ordinates.
+ * @param {number} [options.max=null] For geospatial indexes set the high bound for the co-ordinates.
+ * @param {number} [options.v=null] Specify the format version of the indexes.
+ * @param {number} [options.expireAfterSeconds=null] Allows you to expire data on indexes applied to a data (MongoDB 2.2 or higher)
+ * @param {number} [options.name=null] Override the autogenerated index name (useful if the resulting name is larger than 128 bytes)
+ * @param {Collection~resultCallback} callback The command result callback
+ * @return {null}
+ */
+Collection.prototype.createIndex = function(fieldOrSpec, options, callback) {
+ var args = Array.prototype.slice.call(arguments, 1);
+ callback = args.pop();
+ options = args.length ? args.shift() || {} : {};
+ options = typeof callback === 'function' ? options : callback;
+ options = options == null ? {} : options;
+ // Execute create index
+ this.s.db.createIndex(this.s.name, fieldOrSpec, options, callback);
+}
+
+/**
+ * Creates multiple indexes in the collection, this method is only supported for
+ * MongoDB 2.6 or higher. Earlier version of MongoDB will throw a command not supported
+ * error. Index specifications are defined at http://docs.mongodb.org/manual/reference/command/createIndexes/.
+ * @method
+ * @param {array} indexSpecs An array of index specifications to be created
+ * @param {Collection~resultCallback} callback The command result callback
+ * @return {null}
+ */
+Collection.prototype.createIndexes = function(indexSpecs, callback) {
+ // Ensure we generate the correct name if the parameter is not set
+ for(var i = 0; i < indexSpecs.length; i++) {
+ if(indexSpecs[i].name == null) {
+ var keys = [];
+
+ for(var name in indexSpecs[i].key) {
+ keys.push(f('%s_%s', name, indexSpecs[i].key[name]));
+ }
+
+ // Set the name
+ indexSpecs[i].name = keys.join('_');
+ }
+ }
+
+ // Execute the index
+ this.s.db.command({
+ createIndexes: this.s.name, indexes: indexSpecs
+ }, callback);
+}
+
+/**
+ * Drops an index from this collection.
+ * @method
+ * @param {string} indexName Name of the index to drop.
+ * @param {object} [options=null] Optional settings.
+ * @param {(number|string)} [options.w=null] The write concern.
+ * @param {number} [options.wtimeout=null] The write concern timeout.
+ * @param {boolean} [options.j=false] Specify a journal write concern.
+ * @param {Collection~resultCallback} callback The command result callback
+ * @return {null}
+ */
+Collection.prototype.dropIndex = function(indexName, options, callback) {
+ var args = Array.prototype.slice.call(arguments, 1);
+ callback = args.pop();
+ options = args.length ? args.shift() || {} : {};
+
+ // Delete index command
+ var cmd = {'deleteIndexes':this.s.name, 'index':indexName};
+
+ // Execute command
+ this.s.db.command(cmd, options, function(err, result) {
+ if(typeof callback != 'function') return;
+ if(err) return handleCallback(callback, err, null);
+ handleCallback(callback, null, result);
+ });
+}
+
+/**
+ * Drops all indexes from this collection.
+ * @method
+ * @param {Collection~resultCallback} callback The command result callback
+ * @return {null}
+ */
+Collection.prototype.dropIndexes = function(callback) {
+ this.dropIndex('*', function (err, result) {
+ if(err) return handleCallback(callback, err, false);
+ handleCallback(callback, null, true);
+ });
+}
+
+/**
+ * Drops all indexes from this collection.
+ * @method
+ * @deprecated since version 2.0
+ * @param {Collection~resultCallback} callback The command result callback
+ * @return {null}
+ */
+Collection.prototype.dropAllIndexes = Collection.prototype.dropIndexes;
+
+/**
+ * Reindex all indexes on the collection
+ * Warning: reIndex is a blocking operation (indexes are rebuilt in the foreground) and will be slow for large collections.
+ * @method
+ * @param {Collection~resultCallback} callback The command result callback
+ * @return {null}
+ */
+Collection.prototype.reIndex = function(options, callback) {
+ if(typeof options == 'function') callback = options, options = {};
+ options = options || {};
+
+ // Reindex
+ var cmd = {'reIndex':this.s.name};
+
+ // Execute the command
+ this.s.db.command(cmd, options, function(err, result) {
+ if(callback == null) return;
+ if(err) return handleCallback(callback, err, null);
+ handleCallback(callback, null, result.ok ? true : false);
+ });
+}
+
+/**
+ * Get the list of all indexes information for the collection.
+ *
+ * @method
+ * @param {object} [options=null] Optional settings.
+ * @param {number} [options.batchSize=null] The batchSize for the returned command cursor or if pre 2.8 the systems batch collection
+ * @return {CommandCursor}
+ */
+Collection.prototype.listIndexes = function(options) {
+ options = options || {};
+ // Clone the options
+ options = shallowClone(options);
+ // Set the CommandCursor constructor
+ options.cursorFactory = CommandCursor;
+
+ // We have a list collections command
+ if(this.s.db.serverConfig.capabilities().hasListIndexesCommand) {
+ // Cursor options
+ var cursor = options.batchSize ? {batchSize: options.batchSize} : {}
+ // Build the command
+ var command = { listIndexes: this.s.name, cursor: cursor };
+ // Execute the cursor
+ return this.s.topology.cursor(f('%s.$cmd', this.s.dbName), command, options);
+ }
+
+ // Get the namespace
+ var ns = f('%s.system.indexes', this.s.dbName);
+ // Get the query
+ return this.s.topology.cursor(ns, {find: ns, query: {ns: this.s.namespace}}, options);
+};
+
+/**
+ * Ensures that an index exists, if it does not it creates it
+ * @method
+ * @deprecated since version 2.0
+ * @param {(string|object)} fieldOrSpec Defines the index.
+ * @param {object} [options=null] Optional settings.
+ * @param {(number|string)} [options.w=null] The write concern.
+ * @param {number} [options.wtimeout=null] The write concern timeout.
+ * @param {boolean} [options.j=false] Specify a journal write concern.
+ * @param {boolean} [options.unique=false] Creates an unique index.
+ * @param {boolean} [options.sparse=false] Creates a sparse index.
+ * @param {boolean} [options.background=false] Creates the index in the background, yielding whenever possible.
+ * @param {boolean} [options.dropDups=false] A unique index cannot be created on a key that has pre-existing duplicate values. If you would like to create the index anyway, keeping the first document the database indexes and deleting all subsequent documents that have duplicate value
+ * @param {number} [options.min=null] For geospatial indexes set the lower bound for the co-ordinates.
+ * @param {number} [options.max=null] For geospatial indexes set the high bound for the co-ordinates.
+ * @param {number} [options.v=null] Specify the format version of the indexes.
+ * @param {number} [options.expireAfterSeconds=null] Allows you to expire data on indexes applied to a data (MongoDB 2.2 or higher)
+ * @param {number} [options.name=null] Override the autogenerated index name (useful if the resulting name is larger than 128 bytes)
+ * @param {Collection~resultCallback} callback The command result callback
+ * @return {null}
+ */
+Collection.prototype.ensureIndex = function(fieldOrSpec, options, callback) {
+ if(typeof options == 'function') callback = options, options = {};
+ options = options || {};
+ this.s.db.ensureIndex(this.s.name, fieldOrSpec, options, callback);
+}
+
+/**
+ * Checks if one or more indexes exist on the collection, fails on first non-existing index
+ * @method
+ * @param {(string|array)} indexes One or more index names to check.
+ * @param {Collection~resultCallback} callback The command result callback
+ * @return {null}
+ */
+Collection.prototype.indexExists = function(indexes, callback) {
+ this.indexInformation(function(err, indexInformation) {
+ // If we have an error return
+ if(err != null) return handleCallback(callback, err, null);
+ // Let's check for the index names
+ if(!Array.isArray(indexes)) return handleCallback(callback, null, indexInformation[indexes] != null);
+ // Check in list of indexes
+ for(var i = 0; i < indexes.length; i++) {
+ if(indexInformation[indexes[i]] == null) {
+ return handleCallback(callback, null, false);
+ }
+ }
+
+ // All keys found return true
+ return handleCallback(callback, null, true);
+ });
+}
+
+/**
+ * Retrieves this collections index info.
+ * @method
+ * @param {object} [options=null] Optional settings.
+ * @param {boolean} [options.full=false] Returns the full raw index information.
+ * @param {Collection~resultCallback} callback The command result callback
+ * @return {null}
+ */
+Collection.prototype.indexInformation = function(options, callback) {
+ // Unpack calls
+ var args = Array.prototype.slice.call(arguments, 0);
+ callback = args.pop();
+ options = args.length ? args.shift() || {} : {};
+ // Call the index information
+ this.s.db.indexInformation(this.s.name, options, callback);
+}
+
+/**
+ * The callback format for results
+ * @callback Collection~countCallback
+ * @param {MongoError} error An error instance representing the error during the execution.
+ * @param {number} result The count of documents that matched the query.
+ */
+
+/**
+ * Count number of matching documents in the db to a query.
+ * @method
+ * @param {object} query The query for the count.
+ * @param {object} [options=null] Optional settings.
+ * @param {boolean} [options.limit=null] The limit of documents to count.
+ * @param {boolean} [options.skip=null] The number of documents to skip for the count.
+ * @param {string} [options.hint=null] An index name hint for the query.
+ * @param {(ReadPreference|string)} [options.readPreference=null] The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).
+ * @param {Collection~countCallback} callback The command result callback
+ * @return {null}
+ */
+Collection.prototype.count = function(query, options, callback) {
+ var args = Array.prototype.slice.call(arguments, 0);
+ callback = args.pop();
+ query = args.length ? args.shift() || {} : {};
+ options = args.length ? args.shift() || {} : {};
+ var skip = options.skip;
+ var limit = options.limit;
+ var hint = options.hint;
+ var maxTimeMS = options.maxTimeMS;
+
+ // Final query
+ var cmd = {
+ 'count': this.s.name, 'query': query
+ , 'fields': null
+ };
+
+ // Add limit and skip if defined
+ if(typeof skip == 'number') cmd.skip = skip;
+ if(typeof limit == 'number') cmd.limit = limit;
+ if(hint) options.hint = hint;
+
+ // Ensure we have the right read preference inheritance
+ options = getReadPreference(this, options, this.s.db, this);
+
+ // Execute command
+ this.s.db.command(cmd, options, function(err, result) {
+ if(err) return handleCallback(callback, err);
+ handleCallback(callback, null, result.n);
+ });
+};
+
+/**
+ * The distinct command returns returns a list of distinct values for the given key across a collection.
+ * @method
+ * @param {string} key Field of the document to find distinct values for.
+ * @param {object} query The query for filtering the set of documents to which we apply the distinct filter.
+ * @param {object} [options=null] Optional settings.
+ * @param {(ReadPreference|string)} [options.readPreference=null] The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).
+ * @param {Collection~resultCallback} callback The command result callback
+ * @return {null}
+ */
+Collection.prototype.distinct = function(key, query, options, callback) {
+ var args = Array.prototype.slice.call(arguments, 1);
+ callback = args.pop();
+ query = args.length ? args.shift() || {} : {};
+ options = args.length ? args.shift() || {} : {};
+
+ // maxTimeMS option
+ var maxTimeMS = options.maxTimeMS;
+
+ // Distinct command
+ var cmd = {
+ 'distinct': this.s.name, 'key': key, 'query': query
+ };
+
+ // Ensure we have the right read preference inheritance
+ options = getReadPreference(this, options, this.s.db, this);
+
+ // Execute the command
+ this.s.db.command(cmd, options, function(err, result) {
+ if(err) return handleCallback(callback, err);
+ handleCallback(callback, null, result.values);
+ });
+};
+
+/**
+ * Retrieve all the indexes on the collection.
+ * @method
+ * @param {Collection~resultCallback} callback The command result callback
+ * @return {null}
+ */
+Collection.prototype.indexes = function(callback) {
+ this.s.db.indexInformation(this.s.name, {full:true}, callback);
+}
+
+/**
+ * Get all the collection statistics.
+ *
+ * @method
+ * @param {object} [options=null] Optional settings.
+ * @param {number} [options.scale=null] Divide the returned sizes by scale value.
+ * @param {Collection~resultCallback} callback The collection result callback
+ * @return {null}
+ */
+Collection.prototype.stats = function(options, callback) {
+ var args = Array.prototype.slice.call(arguments, 0);
+ callback = args.pop();
+ // Fetch all commands
+ options = args.length ? args.shift() || {} : {};
+
+ // Build command object
+ var commandObject = {
+ collStats:this.s.name
+ }
+
+ // Check if we have the scale value
+ if(options['scale'] != null) commandObject['scale'] = options['scale'];
+
+ // Ensure we have the right read preference inheritance
+ options = getReadPreference(this, options, this.s.db, this);
+
+ // Execute the command
+ this.s.db.command(commandObject, options, callback);
+}
+
+/**
+ * Find a document and delete it in one atomic operation, requires a write lock for the duration of the operation.
+ *
+ * @method
+ * @param {object} filter Document selection filter.
+ * @param {object} [options=null] Optional settings.
+ * @param {object} [options.projection=null] Limits the fields to return for all matching documents.
+ * @param {object} [options.sort=null] Determines which document the operation modifies if the query selects multiple documents.
+ * @param {number} [options.maxTimeMS=null] The maximum amount of time to allow the query to run.
+ * @param {Collection~resultCallback} callback The collection result callback
+ * @return {null}
+ */
+Collection.prototype.findOneAndDelete = function(filter, options, callback) {
+ if(typeof options == 'function') callback = options, options = {};
+ this.findAndModify(
+ filter
+ , options.sort
+ , null
+ , {
+ fields: options.projection
+ , remove:true
+ }
+ , callback
+ );
+}
+
+/**
+ * Find a document and replace it in one atomic operation, requires a write lock for the duration of the operation.
+ *
+ * @method
+ * @param {object} filter Document selection filter.
+ * @param {object} replacement Document replacing the matching document.
+ * @param {object} [options=null] Optional settings.
+ * @param {object} [options.projection=null] Limits the fields to return for all matching documents.
+ * @param {object} [options.sort=null] Determines which document the operation modifies if the query selects multiple documents.
+ * @param {number} [options.maxTimeMS=null] The maximum amount of time to allow the query to run.
+ * @param {boolean} [options.upsert=false] Upsert the document if it does not exist.
+ * @param {boolean} [options.returnOriginal=true] When false, returns the updated document rather than the original. The default is true.
+ * @param {Collection~resultCallback} callback The collection result callback
+ * @return {null}
+ */
+Collection.prototype.findOneAndReplace = function(filter, replacement, options, callback) {
+ if(typeof options == 'function') callback = options, options = {};
+ this.findAndModify(
+ filter
+ , options.sort
+ , replacement
+ , {
+ fields: options.projection
+ , update: true
+ , new: typeof options.returnOriginal == 'boolean' ? !options.returnOriginal : false
+ , upsert: typeof options.upsert == 'boolean' ? options.upsert : false
+ }
+ , callback
+ );
+}
+
+/**
+ * Find a document and update it in one atomic operation, requires a write lock for the duration of the operation.
+ *
+ * @method
+ * @param {object} filter Document selection filter.
+ * @param {object} update Update operations to be performed on the document
+ * @param {object} [options=null] Optional settings.
+ * @param {object} [options.projection=null] Limits the fields to return for all matching documents.
+ * @param {object} [options.sort=null] Determines which document the operation modifies if the query selects multiple documents.
+ * @param {number} [options.maxTimeMS=null] The maximum amount of time to allow the query to run.
+ * @param {boolean} [options.upsert=false] Upsert the document if it does not exist.
+ * @param {boolean} [options.returnOriginal=true] When false, returns the updated document rather than the original. The default is true.
+ * @param {Collection~resultCallback} callback The collection result callback
+ * @return {null}
+ */
+Collection.prototype.findOneAndUpdate = function(filter, update, options, callback) {
+ if(typeof options == 'function') callback = options, options = {};
+ this.findAndModify(
+ filter
+ , options.sort
+ , update
+ , {
+ fields: options.projection
+ , update: true
+ , new: typeof options.returnOriginal == 'boolean' ? !options.returnOriginal : false
+ , upsert: typeof options.upsert == 'boolean' ? options.upsert : false
+ }
+ , callback
+ );
+}
+
+/**
+ * Find and update a document.
+ * @method
+ * @param {object} query Query object to locate the object to modify.
+ * @param {array} sort If multiple docs match, choose the first one in the specified sort order as the object to manipulate.
+ * @param {object} doc The fields/vals to be updated.
+ * @param {object} [options=null] Optional settings.
+ * @param {(number|string)} [options.w=null] The write concern.
+ * @param {number} [options.wtimeout=null] The write concern timeout.
+ * @param {boolean} [options.j=false] Specify a journal write concern.
+ * @param {boolean} [options.remove=false] Set to true to remove the object before returning.
+ * @param {boolean} [options.upsert=false] Perform an upsert operation.
+ * @param {boolean} [options.new=false] Set to true if you want to return the modified object rather than the original. Ignored for remove.
+ * @param {object} [options.fields=null] Object containing the field projection for the result returned from the operation.
+ * @param {Collection~resultCallback} callback The command result callback
+ * @return {null}
+ * @deprecated
+ */
+Collection.prototype.findAndModify = function(query, sort, doc, options, callback) {
+ var args = Array.prototype.slice.call(arguments, 1);
+ callback = args.pop();
+ sort = args.length ? args.shift() || [] : [];
+ doc = args.length ? args.shift() : null;
+ options = args.length ? args.shift() || {} : {};
+
+ var queryObject = {
+ 'findandmodify': this.s.name
+ , 'query': query
+ };
+
+ sort = formattedOrderClause(sort);
+ if(sort) {
+ queryObject.sort = sort;
+ }
+
+ queryObject.new = options.new ? true : false;
+ queryObject.remove = options.remove ? true : false;
+ queryObject.upsert = options.upsert ? true : false;
+
+ if(options.fields) {
+ queryObject.fields = options.fields;
+ }
+
+ if(doc && !options.remove) {
+ queryObject.update = doc;
+ }
+
+ // Either use override on the function, or go back to default on either the collection
+ // level or db
+ if(options['serializeFunctions'] != null) {
+ options['serializeFunctions'] = options['serializeFunctions'];
+ } else {
+ options['serializeFunctions'] = this.s.serializeFunctions;
+ }
+
+ // No check on the documents
+ options.checkKeys = false;
+
+ // Execute the command
+ this.s.db.command(queryObject
+ , options, function(err, result) {
+ if(err) return handleCallback(callback, err, null);
+ return handleCallback(callback, null, result);
+ });
+}
+
+/**
+ * Find and remove a document.
+ * @method
+ * @param {object} query Query object to locate the object to modify.
+ * @param {array} sort If multiple docs match, choose the first one in the specified sort order as the object to manipulate.
+ * @param {object} [options=null] Optional settings.
+ * @param {(number|string)} [options.w=null] The write concern.
+ * @param {number} [options.wtimeout=null] The write concern timeout.
+ * @param {boolean} [options.j=false] Specify a journal write concern.
+ * @param {Collection~resultCallback} callback The command result callback
+ * @return {null}
+ * @deprecated
+ */
+Collection.prototype.findAndRemove = function(query, sort, options, callback) {
+ var args = Array.prototype.slice.call(arguments, 1);
+ callback = args.pop();
+ sort = args.length ? args.shift() || [] : [];
+ options = args.length ? args.shift() || {} : {};
+ // Add the remove option
+ options['remove'] = true;
+ // Execute the callback
+ this.findAndModify(query, sort, null, options, callback);
+}
+
+/**
+ * Execute an aggregation framework pipeline against the collection, needs MongoDB >= 2.2
+ * @method
+ * @param {object} pipeline Array containing all the aggregation framework commands for the execution.
+ * @param {object} [options=null] Optional settings.
+ * @param {(ReadPreference|string)} [options.readPreference=null] The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).
+ * @param {object} [options.cursor=null] Return the query as cursor, on 2.6 > it returns as a real cursor on pre 2.6 it returns as an emulated cursor.
+ * @param {number} [options.cursor.batchSize=null] The batchSize for the cursor
+ * @param {boolean} [options.explain=false] Explain returns the aggregation execution plan (requires mongodb 2.6 >).
+ * @param {boolean} [options.allowDiskUse=false] allowDiskUse lets the server know if it can use disk to store temporary results for the aggregation (requires mongodb 2.6 >).
+ * @param {number} [options.maxTimeMS=null] maxTimeMS specifies a cumulative time limit in milliseconds for processing operations on the cursor. MongoDB interrupts the operation at the earliest following interrupt point.
+ * @param {Collection~resultCallback} callback The command result callback
+ * @return {(null|AggregationCursor)}
+ */
+Collection.prototype.aggregate = function(pipeline, options, callback) {
+ if(Array.isArray(pipeline)) {
+ // Set up callback if one is provided
+ if(typeof options == 'function') {
+ callback = options;
+ options = {};
+ }
+
+ // If we have no options or callback we are doing
+ // a cursor based aggregation
+ if(options == null && callback == null) {
+ options = {};
+ }
+ } else {
+ // Aggregation pipeline passed as arguments on the method
+ var args = Array.prototype.slice.call(arguments, 0);
+ // Get the callback
+ callback = args.pop();
+ // Get the possible options object
+ var opts = args[args.length - 1];
+ // If it contains any of the admissible options pop it of the args
+ options = opts && (opts.readPreference
+ || opts.explain || opts.cursor || opts.out
+ || opts.maxTimeMS || opts.allowDiskUse) ? args.pop() : {};
+ // Left over arguments is the pipeline
+ pipeline = args;
+ }
+
+ // If out was specified
+ if(typeof options.out == 'string') {
+ pipeline.push({$out: options.out});
+ }
+
+ // Build the command
+ var command = { aggregate : this.s.name, pipeline : pipeline};
+ // If we have allowDiskUse defined
+ if(options.allowDiskUse) command.allowDiskUse = options.allowDiskUse;
+ if(typeof options.maxTimeMS == 'number') command.maxTimeMS = options.maxTimeMS;
+
+ // Ensure we have the right read preference inheritance
+ options = getReadPreference(this, options, this.s.db, this);
+
+ // If explain has been specified add it
+ if(options.explain) command.explain = options.explain;
+
+ // Validate that cursor options is valid
+ if(options.cursor != null && typeof options.cursor != 'object') {
+ throw toError('cursor options must be an object');
+ }
+
+ // Set the AggregationCursor constructor
+ options.cursorFactory = AggregationCursor;
+ if(typeof callback != 'function') {
+ if(this.s.topology.capabilities().hasAggregationCursor) {
+ options.cursor = options.cursor || { batchSize : 1000 };
+ command.cursor = options.cursor;
+ }
+
+ // Allow disk usage command
+ if(typeof options.allowDiskUse == 'boolean') command.allowDiskUse = options.allowDiskUse;
+ if(typeof options.maxTimeMS == 'number') command.maxTimeMS = options.maxTimeMS;
+
+ // Execute the cursor
+ return this.s.topology.cursor(this.s.namespace, command, options);
+ }
+
+ var cursor = null;
+ // We do not allow cursor
+ if(options.cursor) {
+ return this.s.topology.cursor(this.s.namespace, command, options);
+ }
+
+ // Execute the command
+ this.s.db.command(command, options, function(err, result) {
+ if(err) {
+ handleCallback(callback, err);
+ } else if(result['err'] || result['errmsg']) {
+ handleCallback(callback, toError(result));
+ } else if(typeof result == 'object' && result['serverPipeline']) {
+ handleCallback(callback, null, result['serverPipeline']);
+ } else if(typeof result == 'object' && result['stages']) {
+ handleCallback(callback, null, result['stages']);
+ } else {
+ handleCallback(callback, null, result.result);
+ }
+ });
+}
+
+/**
+ * The callback format for results
+ * @callback Collection~parallelCollectionScanCallback
+ * @param {MongoError} error An error instance representing the error during the execution.
+ * @param {Cursor[]} cursors A list of cursors returned allowing for parallel reading of collection.
+ */
+
+/**
+ * Return N number of parallel cursors for a collection allowing parallel reading of entire collection. There are
+ * no ordering guarantees for returned results.
+ * @method
+ * @param {object} [options=null] Optional settings.
+ * @param {(ReadPreference|string)} [options.readPreference=null] The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).
+ * @param {number} [options.batchSize=null] Set the batchSize for the getMoreCommand when iterating over the query results.
+ * @param {number} [options.numCursors=1] The maximum number of parallel command cursors to return (the number of returned cursors will be in the range 1:numCursors)
+ * @param {boolean} [options.raw=false] Return all BSON documents as Raw Buffer documents.
+ * @param {Collection~parallelCollectionScanCallback} callback The command result callback
+ * @return {null}
+ */
+Collection.prototype.parallelCollectionScan = function(options, callback) {
+ var self = this;
+ if(typeof options == 'function') callback = options, options = {numCursors: 1};
+ // Set number of cursors to 1
+ options.numCursors = options.numCursors || 1;
+ options.batchSize = options.batchSize || 1000;
+
+ // Ensure we have the right read preference inheritance
+ options = getReadPreference(this, options, this.s.db, this);
+
+ // Create command object
+ var commandObject = {
+ parallelCollectionScan: this.s.name
+ , numCursors: options.numCursors
+ }
+
+ // Execute the command
+ this.s.db.command(commandObject, options, function(err, result) {
+ if(err) return handleCallback(callback, err, null);
+ if(result == null) return handleCallback(callback, new Error("no result returned for parallelCollectionScan"), null);
+
+ var cursors = [];
+ // Create command cursors for each item
+ for(var i = 0; i < result.cursors.length; i++) {
+ var rawId = result.cursors[i].cursor.id
+ // Convert cursorId to Long if needed
+ var cursorId = typeof rawId == 'number' ? Long.fromNumber(rawId) : rawId;
+
+ // Command cursor options
+ var cmd = {
+ batchSize: options.batchSize
+ , cursorId: cursorId
+ , items: result.cursors[i].cursor.firstBatch
+ }
+
+ // Add a command cursor
+ cursors.push(self.s.topology.cursor(self.s.namespace, cursorId, options));
+ }
+
+ handleCallback(callback, null, cursors);
+ });
+}
+
+/**
+ * Execute the geoNear command to search for items in the collection
+ *
+ * @method
+ * @param {number} x Point to search on the x axis, ensure the indexes are ordered in the same order.
+ * @param {number} y Point to search on the y axis, ensure the indexes are ordered in the same order.
+ * @param {object} [options=null] Optional settings.
+ * @param {(ReadPreference|string)} [options.readPreference=null] The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).
+ * @param {number} [options.num=null] Max number of results to return.
+ * @param {number} [options.minDistance=null] Include results starting at minDistance from a point (2.6 or higher)
+ * @param {number} [options.maxDistance=null] Include results up to maxDistance from the point.
+ * @param {number} [options.distanceMultiplier=null] Include a value to multiply the distances with allowing for range conversions.
+ * @param {object} [options.query=null] Filter the results by a query.
+ * @param {boolean} [options.spherical=false] Perform query using a spherical model.
+ * @param {boolean} [options.uniqueDocs=false] The closest location in a document to the center of the search region will always be returned MongoDB > 2.X.
+ * @param {boolean} [options.includeLocs=false] Include the location data fields in the top level of the results MongoDB > 2.X.
+ * @param {Collection~resultCallback} callback The command result callback
+ * @return {null}
+ */
+Collection.prototype.geoNear = function(x, y, options, callback) {
+ var point = typeof(x) == 'object' && x
+ , args = Array.prototype.slice.call(arguments, point?1:2);
+
+ callback = args.pop();
+ // Fetch all commands
+ options = args.length ? args.shift() || {} : {};
+
+ // Build command object
+ var commandObject = {
+ geoNear:this.s.name,
+ near: point || [x, y]
+ }
+
+ // Ensure we have the right read preference inheritance
+ options = getReadPreference(this, options, this.s.db, this);
+
+ // Exclude readPreference and existing options to prevent user from
+ // shooting themselves in the foot
+ var exclude = {
+ readPreference: true,
+ geoNear: true,
+ near: true
+ };
+
+ // Filter out any excluded objects
+ commandObject = decorateCommand(commandObject, options, exclude);
+
+ // Execute the command
+ this.s.db.command(commandObject, options, function (err, res) {
+ if(err) return handleCallback(callback, err);
+ if(res.err || res.errmsg) return handleCallback(callback, toError(res));
+ // should we only be returning res.results here? Not sure if the user
+ // should see the other return information
+ handleCallback(callback, null, res);
+ });
+}
+
+/**
+ * Execute a geo search using a geo haystack index on a collection.
+ *
+ * @method
+ * @param {number} x Point to search on the x axis, ensure the indexes are ordered in the same order.
+ * @param {number} y Point to search on the y axis, ensure the indexes are ordered in the same order.
+ * @param {object} [options=null] Optional settings.
+ * @param {(ReadPreference|string)} [options.readPreference=null] The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).
+ * @param {number} [options.maxDistance=null] Include results up to maxDistance from the point.
+ * @param {object} [options.search=null] Filter the results by a query.
+ * @param {number} [options.limit=false] Max number of results to return.
+ * @param {Collection~resultCallback} callback The command result callback
+ * @return {null}
+ */
+Collection.prototype.geoHaystackSearch = function(x, y, options, callback) {
+ var args = Array.prototype.slice.call(arguments, 2);
+ callback = args.pop();
+ // Fetch all commands
+ options = args.length ? args.shift() || {} : {};
+
+ // Build command object
+ var commandObject = {
+ geoSearch: this.s.name,
+ near: [x, y]
+ }
+
+ // Remove read preference from hash if it exists
+ commandObject = decorateCommand(commandObject, options, {readPreference: true});
+
+ // Ensure we have the right read preference inheritance
+ options = getReadPreference(this, options, this.s.db, this);
+
+ // Execute the command
+ this.s.db.command(commandObject, options, function (err, res) {
+ if(err) return handleCallback(callback, err);
+ if(res.err || res.errmsg) handleCallback(callback, utils.toError(res));
+ // should we only be returning res.results here? Not sure if the user
+ // should see the other return information
+ handleCallback(callback, null, res);
+ });
+}
+
+/**
+ * Group function helper
+ * @ignore
+ */
+var groupFunction = function () {
+ var c = db[ns].find(condition);
+ var map = new Map();
+ var reduce_function = reduce;
+
+ while (c.hasNext()) {
+ var obj = c.next();
+ var key = {};
+
+ for (var i = 0, len = keys.length; i < len; ++i) {
+ var k = keys[i];
+ key[k] = obj[k];
+ }
+
+ var aggObj = map.get(key);
+
+ if (aggObj == null) {
+ var newObj = Object.extend({}, key);
+ aggObj = Object.extend(newObj, initial);
+ map.put(key, aggObj);
+ }
+
+ reduce_function(obj, aggObj);
+ }
+
+ return { "result": map.values() };
+}.toString();
+
+/**
+ * Run a group command across a collection
+ *
+ * @method
+ * @param {(object|array|function|code)} keys An object, array or function expressing the keys to group by.
+ * @param {object} condition An optional condition that must be true for a row to be considered.
+ * @param {object} initial Initial value of the aggregation counter object.
+ * @param {(function|Code)} reduce The reduce function aggregates (reduces) the objects iterated
+ * @param {(function|Code)} finalize An optional function to be run on each item in the result set just before the item is returned.
+ * @param {boolean} command Specify if you wish to run using the internal group command or using eval, default is true.
+ * @param {object} [options=null] Optional settings.
+ * @param {(ReadPreference|string)} [options.readPreference=null] The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).
+ * @param {Collection~resultCallback} callback The command result callback
+ * @return {null}
+ */
+Collection.prototype.group = function(keys, condition, initial, reduce, finalize, command, options, callback) {
+ var args = Array.prototype.slice.call(arguments, 3);
+ callback = args.pop();
+ // Fetch all commands
+ reduce = args.length ? args.shift() : null;
+ finalize = args.length ? args.shift() : null;
+ command = args.length ? args.shift() : null;
+ options = args.length ? args.shift() || {} : {};
+
+ // Make sure we are backward compatible
+ if(!(typeof finalize == 'function')) {
+ command = finalize;
+ finalize = null;
+ }
+
+ if (!Array.isArray(keys) && keys instanceof Object && typeof(keys) !== 'function' && !(keys instanceof Code)) {
+ keys = Object.keys(keys);
+ }
+
+ if(typeof reduce === 'function') {
+ reduce = reduce.toString();
+ }
+
+ if(typeof finalize === 'function') {
+ finalize = finalize.toString();
+ }
+
+ // Set up the command as default
+ command = command == null ? true : command;
+
+ // Execute using the command
+ if(command) {
+ var reduceFunction = reduce instanceof Code
+ ? reduce
+ : new Code(reduce);
+
+ var selector = {
+ group: {
+ 'ns': this.s.name
+ , '$reduce': reduceFunction
+ , 'cond': condition
+ , 'initial': initial
+ , 'out': "inline"
+ }
+ };
+
+ // if finalize is defined
+ if(finalize != null) selector.group['finalize'] = finalize;
+ // Set up group selector
+ if ('function' === typeof keys || keys instanceof Code) {
+ selector.group.$keyf = keys instanceof Code
+ ? keys
+ : new Code(keys);
+ } else {
+ var hash = {};
+ keys.forEach(function (key) {
+ hash[key] = 1;
+ });
+ selector.group.key = hash;
+ }
+
+ // Ensure we have the right read preference inheritance
+ options = getReadPreference(this, options, this.s.db, this);
+ // Execute command
+ this.s.db.command(selector, options, function(err, result) {
+ if(err) return handleCallback(callback, err, null);
+ handleCallback(callback, null, result.retval);
+ });
+ } else {
+ // Create execution scope
+ var scope = reduce != null && reduce instanceof Code
+ ? reduce.scope
+ : {};
+
+ scope.ns = this.s.name;
+ scope.keys = keys;
+ scope.condition = condition;
+ scope.initial = initial;
+
+ // Pass in the function text to execute within mongodb.
+ var groupfn = groupFunction.replace(/ reduce;/, reduce.toString() + ';');
+
+ this.s.db.eval(new Code(groupfn, scope), function (err, results) {
+ if (err) return handleCallback(callback, err, null);
+ handleCallback(callback, null, results.result || results);
+ });
+ }
+}
+
+/**
+ * Functions that are passed as scope args must
+ * be converted to Code instances.
+ * @ignore
+ */
+function processScope (scope) {
+ if(!isObject(scope)) {
+ return scope;
+ }
+
+ var keys = Object.keys(scope);
+ var i = keys.length;
+ var key;
+ var new_scope = {};
+
+ while (i--) {
+ key = keys[i];
+ if ('function' == typeof scope[key]) {
+ new_scope[key] = new Code(String(scope[key]));
+ } else {
+ new_scope[key] = processScope(scope[key]);
+ }
+ }
+
+ return new_scope;
+}
+
+/**
+ * Run Map Reduce across a collection. Be aware that the inline option for out will return an array of results not a collection.
+ *
+ * @method
+ * @param {(function|string)} map The mapping function.
+ * @param {(function|string)} reduce The reduce function.
+ * @param {object} [options=null] Optional settings.
+ * @param {(ReadPreference|string)} [options.readPreference=null] The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).
+ * @param {object} [options.out=null] Sets the output target for the map reduce job. *{inline:1} | {replace:'collectionName'} | {merge:'collectionName'} | {reduce:'collectionName'}*
+ * @param {object} [options.query=null] Query filter object.
+ * @param {object} [options.sort=null] Sorts the input objects using this key. Useful for optimization, like sorting by the emit key for fewer reduces.
+ * @param {number} [options.limit=null] Number of objects to return from collection.
+ * @param {boolean} [options.keeptemp=false] Keep temporary data.
+ * @param {(function|string)} [options.finalize=null] Finalize function.
+ * @param {object} [options.scope=null] Can pass in variables that can be access from map/reduce/finalize.
+ * @param {boolean} [options.jsMode=false] It is possible to make the execution stay in JS. Provided in MongoDB > 2.0.X.
+ * @param {boolean} [options.verbose=false] Provide statistics on job execution time.
+ * @param {Collection~resultCallback} callback The command result callback
+ * @throws {MongoError}
+ * @return {null}
+ */
+Collection.prototype.mapReduce = function(map, reduce, options, callback) {
+ var self = this;
+ if('function' === typeof options) callback = options, options = {};
+ // Out must allways be defined (make sure we don't break weirdly on pre 1.8+ servers)
+ if(null == options.out) {
+ throw new Error("the out option parameter must be defined, see mongodb docs for possible values");
+ }
+
+ if('function' === typeof map) {
+ map = map.toString();
+ }
+
+ if('function' === typeof reduce) {
+ reduce = reduce.toString();
+ }
+
+ if('function' === typeof options.finalize) {
+ options.finalize = options.finalize.toString();
+ }
+
+ var mapCommandHash = {
+ mapreduce: this.s.name
+ , map: map
+ , reduce: reduce
+ };
+
+ // Add any other options passed in
+ for(var n in options) {
+ if('scope' == n) {
+ mapCommandHash[n] = processScope(options[n]);
+ } else {
+ mapCommandHash[n] = options[n];
+ }
+ }
+
+ // Ensure we have the right read preference inheritance
+ options = getReadPreference(this, options, this.s.db, this);
+
+ // If we have a read preference and inline is not set as output fail hard
+ if((options.readPreference != false && options.readPreference != 'primary')
+ && options['out'] && (options['out'].inline != 1 && options['out'] != 'inline')) {
+ options.readPreference = 'primary';
+ }
+
+ // Execute command
+ this.s.db.command(mapCommandHash, {readPreference:options.readPreference}, function (err, result) {
+ if(err) return handleCallback(callback, err);
+ // Check if we have an error
+ if(1 != result.ok || result.err || result.errmsg) {
+ return handleCallback(callback, toError(result));
+ }
+
+ // Create statistics value
+ var stats = {};
+ if(result.timeMillis) stats['processtime'] = result.timeMillis;
+ if(result.counts) stats['counts'] = result.counts;
+ if(result.timing) stats['timing'] = result.timing;
+
+ // invoked with inline?
+ if(result.results) {
+ // If we wish for no verbosity
+ if(options['verbose'] == null || !options['verbose']) {
+ return handleCallback(callback, null, result.results);
+ }
+
+ return handleCallback(callback, null, result.results, stats);
+ }
+
+ // The returned collection
+ var collection = null;
+
+ // If we have an object it's a different db
+ if(result.result != null && typeof result.result == 'object') {
+ var doc = result.result;
+ collection = self.s.db.db(doc.db).collection(doc.collection);
+ } else {
+ // Create a collection object that wraps the result collection
+ collection = self.s.db.collection(result.result)
+ }
+
+ // If we wish for no verbosity
+ if(options['verbose'] == null || !options['verbose']) {
+ return handleCallback(callback, err, collection);
+ }
+
+ // Return stats as third set of values
+ handleCallback(callback, err, collection, stats);
+ });
+}
+
+/**
+ * Initiate a Out of order batch write operation. All operations will be buffered into insert/update/remove commands executed out of order.
+ *
+ * @method
+ * @param {object} [options=null] Optional settings.
+ * @param {(number|string)} [options.w=null] The write concern.
+ * @param {number} [options.wtimeout=null] The write concern timeout.
+ * @param {boolean} [options.j=false] Specify a journal write concern.
+ * @param {UnorderedBulkOperation} callback The command result callback
+ * @return {null}
+ */
+Collection.prototype.initializeUnorderedBulkOp = function(options) {
+ return unordered(this.s.topology, this, options);
+}
+
+/**
+ * Initiate an In order bulk write operation, operations will be serially executed in the order they are added, creating a new operation for each switch in types.
+ *
+ * @method
+ * @param {object} [options=null] Optional settings.
+ * @param {(number|string)} [options.w=null] The write concern.
+ * @param {number} [options.wtimeout=null] The write concern timeout.
+ * @param {boolean} [options.j=false] Specify a journal write concern.
+ * @param {OrderedBulkOperation} callback The command result callback
+ * @return {null}
+ */
+Collection.prototype.initializeOrderedBulkOp = function(options) {
+ return ordered(this.s.topology, this, options);
+}
+
+// Get write concern
+var writeConcern = function(target, db, col, options) {
+ if(options.w != null || options.j != null || options.fsync != null) {
+ var opts = {};
+ if(options.w != null) opts.w = options.w;
+ if(options.wtimeout != null) opts.wtimeout = options.wtimeout;
+ if(options.j != null) opts.j = options.j;
+ if(options.fsync != null) opts.fsync = options.fsync;
+ target.writeConcern = opts;
+ } else if(col.writeConcern.w != null || col.writeConcern.j != null || col.writeConcern.fsync != null) {
+ target.writeConcern = col.writeConcern;
+ } else if(db.writeConcern.w != null || db.writeConcern.j != null || db.writeConcern.fsync != null) {
+ target.writeConcern = db.writeConcern;
+ }
+
+ return target
+}
+
+// Figure out the read preference
+var getReadPreference = function(self, options, db, coll) {
+ var r = null
+ if(options.readPreference) {
+ r = options.readPreference
+ } else if(self.s.readPreference) {
+ r = self.s.readPreference
+ } else if(db.readPreference) {
+ r = db.readPreference;
+ }
+
+ if(r instanceof ReadPreference) {
+ options.readPreference = new CoreReadPreference(r.mode, r.tags);
+ } else if(typeof r == 'string') {
+ options.readPreference = new CoreReadPreference(r);
+ }
+
+ return options;
+}
+
+var testForFields = {
+ limit: 1, sort: 1, fields:1, skip: 1, hint: 1, explain: 1, snapshot: 1, timeout: 1, tailable: 1, tailableRetryInterval: 1
+ , numberOfRetries: 1, awaitdata: 1, awaitData: 1, exhaust: 1, batchSize: 1, returnKey: 1, maxScan: 1, min: 1, max: 1, showDiskLoc: 1
+ , comment: 1, raw: 1, readPreference: 1, partial: 1, read: 1, dbName: 1, oplogReplay: 1, connection: 1, maxTimeMS: 1, transforms: 1
+}
+
+module.exports = Collection;
diff --git a/server/node_modules/mongodb/lib/command_cursor.js b/server/node_modules/mongodb/lib/command_cursor.js
new file mode 100755
index 00000000..fc51f60f
--- /dev/null
+++ b/server/node_modules/mongodb/lib/command_cursor.js
@@ -0,0 +1,279 @@
+"use strict";
+
+var inherits = require('util').inherits
+ , f = require('util').format
+ , toError = require('./utils').toError
+ , getSingleProperty = require('./utils').getSingleProperty
+ , formattedOrderClause = require('./utils').formattedOrderClause
+ , handleCallback = require('./utils').handleCallback
+ , Logger = require('mongodb-core').Logger
+ , EventEmitter = require('events').EventEmitter
+ , ReadPreference = require('./read_preference')
+ , MongoError = require('mongodb-core').MongoError
+ , Readable = require('stream').Readable || require('readable-stream').Readable
+ // , CoreCursor = require('mongodb-core').Cursor
+ , CoreCursor = require('./cursor')
+ , Query = require('mongodb-core').Query
+ , CoreReadPreference = require('mongodb-core').ReadPreference;
+
+/**
+ * @fileOverview The **CommandCursor** class is an internal class that embodies a
+ * generalized cursor based on a MongoDB command allowing for iteration over the
+ * results returned. It supports one by one document iteration, conversion to an
+ * array or can be iterated as a Node 0.10.X or higher stream
+ *
+ * **CommandCursor Cannot directly be instantiated**
+ * @example
+ * var MongoClient = require('mongodb').MongoClient,
+ * test = require('assert');
+ * // Connection url
+ * var url = 'mongodb://localhost:27017/test';
+ * // Connect using MongoClient
+ * MongoClient.connect(url, function(err, db) {
+ * // Create a collection we want to drop later
+ * var col = db.collection('listCollectionsExample1');
+ * // Insert a bunch of documents
+ * col.insert([{a:1, b:1}
+ * , {a:2, b:2}, {a:3, b:3}
+ * , {a:4, b:4}], {w:1}, function(err, result) {
+ * test.equal(null, err);
+ *
+ * // List the database collections available
+ * db.listCollections().toArray(function(err, items) {
+ * test.equal(null, err);
+ * db.close();
+ * });
+ * });
+ * });
+ */
+
+/**
+ * Namespace provided by the browser.
+ * @external Readable
+ */
+
+/**
+ * Creates a new Command Cursor instance (INTERNAL TYPE, do not instantiate directly)
+ * @class
+ * @extends external:Readable
+ * @fires CommandCursor#data
+ * @fires CommandCursor#end
+ * @fires CommandCursor#close
+ * @fires CommandCursor#readable
+ * @return {CommandCursor} an CommandCursor instance.
+ */
+var CommandCursor = function(bson, ns, cmd, options, topology, topologyOptions) {
+ CoreCursor.apply(this, Array.prototype.slice.call(arguments, 0));
+ var self = this;
+ var state = CommandCursor.INIT;
+ var streamOptions = {};
+
+ // MaxTimeMS
+ var maxTimeMS = null;
+
+ // Set up
+ Readable.call(this, {objectMode: true});
+
+ // Internal state
+ this.s = {
+ // MaxTimeMS
+ maxTimeMS: maxTimeMS
+ // State
+ , state: state
+ // Stream options
+ , streamOptions: streamOptions
+ // BSON
+ , bson: bson
+ // Namespae
+ , ns: ns
+ // Command
+ , cmd: cmd
+ // Options
+ , options: options
+ // Topology
+ , topology: topology
+ // Topology Options
+ , topologyOptions: topologyOptions
+ }
+}
+
+/**
+ * CommandCursor stream data event, fired for each document in the cursor.
+ *
+ * @event CommandCursor#data
+ * @type {object}
+ */
+
+/**
+ * CommandCursor stream end event
+ *
+ * @event CommandCursor#end
+ * @type {null}
+ */
+
+/**
+ * CommandCursor stream close event
+ *
+ * @event CommandCursor#close
+ * @type {null}
+ */
+
+/**
+ * CommandCursor stream readable event
+ *
+ * @event CommandCursor#readable
+ * @type {null}
+ */
+
+// Inherit from Readable
+inherits(CommandCursor, Readable);
+
+// Set the methods to inherit from prototype
+var methodsToInherit = ['next', 'each', 'forEach', 'toArray'
+ , 'rewind', 'bufferedCount', 'readBufferedDocuments', 'close', 'isClosed'];
+
+// Only inherit the types we need
+for(var i = 0; i < methodsToInherit.length; i++) {
+ CommandCursor.prototype[methodsToInherit[i]] = CoreCursor.prototype[methodsToInherit[i]];
+}
+
+/**
+ * Set the batch size for the cursor.
+ * @method
+ * @param {number} value The batchSize for the cursor.
+ * @throws {MongoError}
+ * @return {CommandCursor}
+ */
+CommandCursor.prototype.batchSize = function(value) {
+ if(this.s.state == CommandCursor.CLOSED || this.isDead()) throw new MongoError("Cursor is closed");
+ if(typeof value != 'number') throw new MongoError("batchSize requires an integer");
+ if(this.s.cmd.cursor) this.s.cmd.cursor.batchSize = value;
+ this.setCursorBatchSize(value);
+ return this;
+}
+
+/**
+ * Add a maxTimeMS stage to the aggregation pipeline
+ * @method
+ * @param {number} value The state maxTimeMS value.
+ * @return {CommandCursor}
+ */
+CommandCursor.prototype.maxTimeMS = function(value) {
+ if(this.s.topology.lastIsMaster().minWireVersion > 2) {
+ this.s.cmd.maxTimeMS = value;
+ }
+ return this;
+}
+
+CommandCursor.prototype.get = CommandCursor.prototype.toArray;
+
+/**
+ * Get the next available document from the cursor, returns null if no more documents are available.
+ * @function CommandCursor.prototype.next
+ * @param {CommandCursor~resultCallback} callback The result callback.
+ * @throws {MongoError}
+ * @return {null}
+ */
+
+/**
+ * Set the new batchSize of the cursor
+ * @function CommandCursor.prototype.setBatchSize
+ * @param {number} value The new batchSize for the cursor
+ * @return {null}
+ */
+
+/**
+ * Get the batchSize of the cursor
+ * @function CommandCursor.prototype.batchSize
+ * @param {number} value The current batchSize for the cursor
+ * @return {null}
+ */
+
+/**
+ * The callback format for results
+ * @callback CommandCursor~toArrayResultCallback
+ * @param {MongoError} error An error instance representing the error during the execution.
+ * @param {object[]} documents All the documents the satisfy the cursor.
+ */
+
+/**
+ * Returns an array of documents. The caller is responsible for making sure that there
+ * is enough memory to store the results. Note that the array only contain partial
+ * results when this cursor had been previouly accessed.
+ * @method CommandCursor.prototype.toArray
+ * @param {CommandCursor~toArrayResultCallback} callback The result callback.
+ * @throws {MongoError}
+ * @return {null}
+ */
+
+/**
+ * The callback format for results
+ * @callback CommandCursor~resultCallback
+ * @param {MongoError} error An error instance representing the error during the execution.
+ * @param {(object|null)} result The result object if the command was executed successfully.
+ */
+
+/**
+ * Iterates over all the documents for this cursor. As with **{cursor.toArray}**,
+ * not all of the elements will be iterated if this cursor had been previouly accessed.
+ * In that case, **{cursor.rewind}** can be used to reset the cursor. However, unlike
+ * **{cursor.toArray}**, the cursor will only hold a maximum of batch size elements
+ * at any given time if batch size is specified. Otherwise, the caller is responsible
+ * for making sure that the entire result can fit the memory.
+ * @method CommandCursor.prototype.each
+ * @param {CommandCursor~resultCallback} callback The result callback.
+ * @throws {MongoError}
+ * @return {null}
+ */
+
+/**
+ * Close the cursor, sending a KillCursor command and emitting close.
+ * @method CommandCursor.prototype.close
+ * @param {CommandCursor~resultCallback} [callback] The result callback.
+ * @return {null}
+ */
+
+/**
+ * Is the cursor closed
+ * @method CommandCursor.prototype.isClosed
+ * @return {boolean}
+ */
+
+/**
+ * Clone the cursor
+ * @function CommandCursor.prototype.clone
+ * @return {CommandCursor}
+ */
+
+/**
+ * Resets the cursor
+ * @function CommandCursor.prototype.rewind
+ * @return {CommandCursor}
+ */
+
+/**
+ * The callback format for the forEach iterator method
+ * @callback CommandCursor~iteratorCallback
+ * @param {Object} doc An emitted document for the iterator
+ */
+
+/**
+ * The callback error format for the forEach iterator method
+ * @callback CommandCursor~endCallback
+ * @param {MongoError} error An error instance representing the error during the execution.
+ */
+
+/*
+ * Iterates over all the documents for this cursor using the iterator, callback pattern.
+ * @method CommandCursor.prototype.forEach
+ * @param {CommandCursor~iteratorCallback} iterator The iteration callback.
+ * @param {CommandCursor~endCallback} callback The end callback.
+ * @throws {MongoError}
+ * @return {null}
+ */
+
+CommandCursor.INIT = 0;
+CommandCursor.OPEN = 1;
+CommandCursor.CLOSED = 2;
+
+module.exports = CommandCursor;
\ No newline at end of file
diff --git a/server/node_modules/mongodb/lib/cursor.js b/server/node_modules/mongodb/lib/cursor.js
new file mode 100755
index 00000000..9e6abc1f
--- /dev/null
+++ b/server/node_modules/mongodb/lib/cursor.js
@@ -0,0 +1,836 @@
+"use strict";
+
+var inherits = require('util').inherits
+ , f = require('util').format
+ , toError = require('./utils').toError
+ , getSingleProperty = require('./utils').getSingleProperty
+ , formattedOrderClause = require('./utils').formattedOrderClause
+ , handleCallback = require('./utils').handleCallback
+ , Logger = require('mongodb-core').Logger
+ , EventEmitter = require('events').EventEmitter
+ , ReadPreference = require('./read_preference')
+ , MongoError = require('mongodb-core').MongoError
+ , Readable = require('stream').Readable || require('readable-stream').Readable
+ , CoreCursor = require('mongodb-core').Cursor
+ , Query = require('mongodb-core').Query
+ , CoreReadPreference = require('mongodb-core').ReadPreference;
+
+/**
+ * @fileOverview The **Cursor** class is an internal class that embodies a cursor on MongoDB
+ * allowing for iteration over the results returned from the underlying query. It supports
+ * one by one document iteration, conversion to an array or can be iterated as a Node 0.10.X
+ * or higher stream
+ *
+ * **CURSORS Cannot directly be instantiated**
+ * @example
+ * var MongoClient = require('mongodb').MongoClient,
+ * test = require('assert');
+ * // Connection url
+ * var url = 'mongodb://localhost:27017/test';
+ * // Connect using MongoClient
+ * MongoClient.connect(url, function(err, db) {
+ * // Create a collection we want to drop later
+ * var col = db.collection('createIndexExample1');
+ * // Insert a bunch of documents
+ * col.insert([{a:1, b:1}
+ * , {a:2, b:2}, {a:3, b:3}
+ * , {a:4, b:4}], {w:1}, function(err, result) {
+ * test.equal(null, err);
+ *
+ * // Show that duplicate records got dropped
+ * col.find({}).toArray(function(err, items) {
+ * test.equal(null, err);
+ * test.equal(4, items.length);
+ * db.close();
+ * });
+ * });
+ * });
+ */
+
+/**
+ * Namespace provided by the mongodb-core and node.js
+ * @external CoreCursor
+ * @external Readable
+ */
+
+// Flags allowed for cursor
+var flags = ['tailable', 'oplogReplay', 'noCursorTimeout', 'awaitData', 'exhaust', 'partial'];
+
+/**
+ * Creates a new Cursor instance (INTERNAL TYPE, do not instantiate directly)
+ * @class
+ * @extends external:CoreCursor
+ * @extends external:Readable
+ * @property {string} sortValue Cursor query sort setting.
+ * @property {boolean} timeout Is Cursor able to time out.
+ * @property {ReadPreference} readPreference Get cursor ReadPreference.
+ * @fires Cursor#data
+ * @fires Cursor#end
+ * @fires Cursor#close
+ * @fires Cursor#readable
+ * @return {Cursor} a Cursor instance.
+ * @example
+ * Some example
+ */
+var Cursor = function(bson, ns, cmd, options, topology, topologyOptions) {
+ CoreCursor.apply(this, Array.prototype.slice.call(arguments, 0));
+ var self = this;
+ var state = Cursor.INIT;
+ var streamOptions = {};
+
+ // Tailable cursor options
+ var numberOfRetries = options.numberOfRetries || 5;
+ var tailableRetryInterval = options.tailableRetryInterval || 500;
+ var currentNumberOfRetries = numberOfRetries;
+ // MaxTimeMS
+ var maxTimeMS = null;
+
+ // Set up
+ Readable.call(this, {objectMode: true});
+
+ // Internal cursor state
+ this.s = {
+ // MaxTimeMS
+ maxTimeMS: null
+ // Tailable cursor options
+ , numberOfRetries: numberOfRetries
+ , tailableRetryInterval: tailableRetryInterval
+ , currentNumberOfRetries: currentNumberOfRetries
+ // State
+ , state: state
+ // Stream options
+ , streamOptions: streamOptions
+ // BSON
+ , bson: bson
+ // Namespace
+ , ns: ns
+ // Command
+ , cmd: cmd
+ // Options
+ , options: options
+ // Topology
+ , topology: topology
+ // Topology options
+ , topologyOptions: topologyOptions
+ }
+
+ // Legacy fields
+ this.timeout = self.s.options.noCursorTimeout == true;
+ this.sortValue = self.s.cmd.sort;
+ this.readPreference = self.s.options.readPreference;
+}
+
+/**
+ * Cursor stream data event, fired for each document in the cursor.
+ *
+ * @event Cursor#data
+ * @type {object}
+ */
+
+/**
+ * Cursor stream end event
+ *
+ * @event Cursor#end
+ * @type {null}
+ */
+
+/**
+ * Cursor stream close event
+ *
+ * @event Cursor#close
+ * @type {null}
+ */
+
+/**
+ * Cursor stream readable event
+ *
+ * @event Cursor#readable
+ * @type {null}
+ */
+
+// Inherit from Readable
+inherits(Cursor, Readable);
+
+for(var name in CoreCursor.prototype) {
+ Cursor.prototype[name] = CoreCursor.prototype[name];
+}
+
+/**
+ * Set the cursor query
+ * @method
+ * @param {object} filter The filter object used for the cursor.
+ * @return {Cursor}
+ */
+Cursor.prototype.filter = function(filter) {
+ if(this.s.state == Cursor.CLOSED || this.s.state == Cursor.OPEN || this.isDead()) throw new MongoError("Cursor is closed");
+ this.s.cmd.query = filter;
+ return this;
+}
+
+/**
+ * Add a cursor flag to the cursor
+ * @method
+ * @param {string} flag The flag to set, must be one of following ['tailable', 'oplogReplay', 'noCursorTimeout', 'awaitData', 'exhaust', 'partial'].
+ * @param {boolean} value The flag boolean value.
+ * @throws {MongoError}
+ * @return {Cursor}
+ */
+Cursor.prototype.addCursorFlag = function(flag, value) {
+ if(this.s.state == Cursor.CLOSED || this.s.state == Cursor.OPEN || this.isDead()) throw new MongoError("Cursor is closed");
+ if(flags.indexOf(flag) == -1) throw new MongoError(f("flag % not a supported flag %s", flag, flags));
+ if(typeof value != 'boolean') throw new MongoError(f("flag % must be a boolean value", flag));
+ this.s.cmd[flag] = value;
+ return this;
+}
+
+/**
+ * Add a query modifier to the cursor query
+ * @method
+ * @param {string} name The query modifier (must start with $, such as $orderby etc)
+ * @param {boolean} value The flag boolean value.
+ * @throws {MongoError}
+ * @return {Cursor}
+ */
+Cursor.prototype.addQueryModifier = function(name, value) {
+ if(this.s.state == Cursor.CLOSED || this.s.state == Cursor.OPEN || this.isDead()) throw new MongoError("Cursor is closed");
+ if(name[0] != '$') throw new MongoError(f("%s is not a valid query modifier"));
+ // Strip of the $
+ var field = name.substr(1);
+ // Set on the command
+ this.s.cmd[field] = value;
+ // Deal with the special case for sort
+ if(field == 'orderby') this.s.cmd.sort = this.s.cmd[field];
+ return this;
+}
+
+/**
+ * Add a comment to the cursor query allowing for tracking the comment in the log.
+ * @method
+ * @param {string} value The comment attached to this query.
+ * @throws {MongoError}
+ * @return {Cursor}
+ */
+Cursor.prototype.comment = function(value) {
+ if(this.s.state == Cursor.CLOSED || this.s.state == Cursor.OPEN || this.isDead()) throw new MongoError("Cursor is closed");
+ this.s.cmd.comment = value;
+ return this;
+}
+
+/**
+ * Set a maxTimeMS on the cursor query, allowing for hard timeout limits on queries (Only supported on MongoDB 2.6 or higher)
+ * @method
+ * @param {number} value Number of milliseconds to wait before aborting the query.
+ * @throws {MongoError}
+ * @return {Cursor}
+ */
+Cursor.prototype.maxTimeMS = function(value) {
+ if(typeof value != 'number') throw new MongoError("maxTimeMS must be a number");
+ if(this.s.state == Cursor.CLOSED || this.s.state == Cursor.OPEN || this.isDead()) throw new MongoError("Cursor is closed");
+ this.s.maxTimeMS = value;
+ this.s.cmd.maxTimeMS = value;
+ return this;
+}
+
+Cursor.prototype.maxTimeMs = Cursor.prototype.maxTimeMS;
+
+/**
+ * Sets a field projection for the query.
+ * @method
+ * @param {object} value The field projection object.
+ * @throws {MongoError}
+ * @return {Cursor}
+ */
+Cursor.prototype.project = function(value) {
+ if(this.s.state == Cursor.CLOSED || this.s.state == Cursor.OPEN || this.isDead()) throw new MongoError("Cursor is closed");
+ this.s.cmd.fields = value;
+ return this;
+}
+
+/**
+ * Sets the sort order of the cursor query.
+ * @method
+ * @param {(string|array|object)} keyOrList The key or keys set for the sort.
+ * @param {number} [direction] The direction of the sorting (1 or -1).
+ * @throws {MongoError}
+ * @return {Cursor}
+ */
+Cursor.prototype.sort = function(keyOrList, direction) {
+ if(this.s.options.tailable) throw new MongoError("Tailable cursor doesn't support sorting");
+ if(this.s.state == Cursor.CLOSED || this.s.state == Cursor.OPEN || this.isDead()) throw new MongoError("Cursor is closed");
+ var order = keyOrList;
+
+ if(direction != null) {
+ order = [[keyOrList, direction]];
+ }
+
+ this.s.cmd.sort = order;
+ this.sortValue = order;
+ return this;
+}
+
+/**
+ * Set the batch size for the cursor.
+ * @method
+ * @param {number} value The batchSize for the cursor.
+ * @throws {MongoError}
+ * @return {Cursor}
+ */
+Cursor.prototype.batchSize = function(value) {
+ if(this.s.options.tailable) throw new MongoError("Tailable cursor doesn't support limit");
+ if(this.s.state == Cursor.CLOSED || this.isDead()) throw new MongoError("Cursor is closed");
+ if(typeof value != 'number') throw new MongoError("batchSize requires an integer");
+ this.s.cmd.batchSize = value;
+ this.setCursorBatchSize(value);
+ return this;
+}
+
+/**
+ * Set the limit for the cursor.
+ * @method
+ * @param {number} value The limit for the cursor query.
+ * @throws {MongoError}
+ * @return {Cursor}
+ */
+Cursor.prototype.limit = function(value) {
+ if(this.s.options.tailable) throw new MongoError("Tailable cursor doesn't support limit");
+ if(this.s.state == Cursor.OPEN || this.s.state == Cursor.CLOSED || this.isDead()) throw new MongoError("Cursor is closed");
+ if(typeof value != 'number') throw new MongoError("limit requires an integer");
+ this.s.cmd.limit = value;
+ // this.cursorLimit = value;
+ this.setCursorLimit(value);
+ return this;
+}
+
+/**
+ * Set the skip for the cursor.
+ * @method
+ * @param {number} value The skip for the cursor query.
+ * @throws {MongoError}
+ * @return {Cursor}
+ */
+Cursor.prototype.skip = function(value) {
+ if(this.s.options.tailable) throw new MongoError("Tailable cursor doesn't support skip");
+ if(this.s.state == Cursor.OPEN || this.s.state == Cursor.CLOSED || this.isDead()) throw new MongoError("Cursor is closed");
+ if(typeof value != 'number') throw new MongoError("skip requires an integer");
+ this.s.cmd.skip = value;
+ this.setCursorSkip(value);
+ return this;
+}
+
+/**
+ * The callback format for results
+ * @callback Cursor~resultCallback
+ * @param {MongoError} error An error instance representing the error during the execution.
+ * @param {(object|null)} result The result object if the command was executed successfully.
+ */
+
+/**
+ * Get the next available document from the cursor, returns null if no more documents are available.
+ * @function external:CoreCursor#next
+ * @param {Cursor~resultCallback} callback The result callback.
+ * @throws {MongoError}
+ * @return {null}
+ */
+
+/**
+ * Set the new batchSize of the cursor
+ * @function Cursor.prototype.setBatchSize
+ * @param {number} value The new batchSize for the cursor
+ * @return {null}
+ */
+
+/**
+ * Get the batchSize of the cursor
+ * @function Cursor.prototype.batchSize
+ * @param {number} value The current batchSize for the cursor
+ * @return {null}
+ */
+
+/**
+ * Set the new skip value of the cursor
+ * @function Cursor.prototype.setCursorSkip
+ * @param {number} value The new skip for the cursor
+ * @return {null}
+ */
+
+/**
+ * Get the skip value of the cursor
+ * @function Cursor.prototype.cursorSkip
+ * @param {number} value The current skip value for the cursor
+ * @return {null}
+ */
+
+/**
+ * Set the new limit value of the cursor
+ * @function Cursor.prototype.setCursorLimit
+ * @param {number} value The new limit for the cursor
+ * @return {null}
+ */
+
+/**
+ * Get the limit value of the cursor
+ * @function Cursor.prototype.cursorLimit
+ * @param {number} value The current limit value for the cursor
+ * @return {null}
+ */
+
+/**
+ * Clone the cursor
+ * @function external:CoreCursor#clone
+ * @return {Cursor}
+ */
+
+/**
+ * Resets the cursor
+ * @function external:CoreCursor#rewind
+ * @return {null}
+ */
+
+/**
+ * Get the next available document from the cursor, returns null if no more documents are available.
+ * @method
+ * @param {Cursor~resultCallback} callback The result callback.
+ * @throws {MongoError}
+ * @deprecated
+ * @return {null}
+ */
+Cursor.prototype.nextObject = function(callback) {
+ var self = this;
+ if(this.s.state == Cursor.CLOSED || self.isDead()) return handleCallback(callback, new MongoError("Cursor is closed"));
+ if(this.s.state == Cursor.INIT && this.s.cmd.sort) {
+ try {
+ this.s.cmd.sort = formattedOrderClause(this.s.cmd.sort);
+ } catch(err) {
+ return handleCallback(callback, err);
+ }
+ }
+
+ // Get the next object
+ self.next(function(err, doc) {
+ if(err && err.tailable && self.s.currentNumberOfRetries == 0) return callback(err);
+ if(err && err.tailable && self.s.currentNumberOfRetries > 0) {
+ self.s.currentNumberOfRetries = self.s.currentNumberOfRetries - 1;
+ return setTimeout(function() {
+ self.nextObject(callback);
+ }, self.s.tailableRetryInterval);
+ }
+
+ self.s.state = Cursor.OPEN;
+ if(err) return handleCallback(callback, err);
+ handleCallback(callback, null, doc);
+ });
+}
+
+// Trampoline emptying the number of retrieved items
+// without incurring a nextTick operation
+var loop = function(self, callback) {
+ // No more items we are done
+ if(self.bufferedCount() == 0) return;
+ // Get the next document
+ self.next(callback);
+ // Loop
+ return loop;
+}
+
+/**
+ * Iterates over all the documents for this cursor. As with **{cursor.toArray}**,
+ * not all of the elements will be iterated if this cursor had been previouly accessed.
+ * In that case, **{cursor.rewind}** can be used to reset the cursor. However, unlike
+ * **{cursor.toArray}**, the cursor will only hold a maximum of batch size elements
+ * at any given time if batch size is specified. Otherwise, the caller is responsible
+ * for making sure that the entire result can fit the memory.
+ * @method
+ * @deprecated
+ * @param {Cursor~resultCallback} callback The result callback.
+ * @throws {MongoError}
+ * @return {null}
+ */
+Cursor.prototype.each = function(callback) {
+ // Rewind cursor state
+ this.rewind();
+ // Set current cursor to INIT
+ this.s.state = Cursor.INIT;
+ // Run the query
+ _each(this, callback);
+};
+
+// Run the each loop
+var _each = function(self, callback) {
+ if(!callback) throw new MongoError('callback is mandatory');
+ if(self.isNotified()) return;
+ if(self.s.state == Cursor.CLOSED || self.isDead()) {
+ return handleCallback(callback, new MongoError("Cursor is closed"), null);
+ }
+
+ if(self.s.state == Cursor.INIT) self.s.state = Cursor.OPEN;
+
+ // Define function to avoid global scope escape
+ var fn = null;
+ // Trampoline all the entries
+ if(self.bufferedCount() > 0) {
+ while(fn = loop(self, callback)) fn(self, callback);
+ _each(self, callback);
+ } else {
+ self.next(function(err, item) {
+ if(err) return handleCallback(callback, err);
+ if(item == null) {
+ self.s.state = Cursor.CLOSED;
+ return handleCallback(callback, null, null);
+ }
+
+ if(handleCallback(callback, null, item) == false) return;
+ _each(self, callback);
+ })
+ }
+}
+
+/**
+ * The callback format for the forEach iterator method
+ * @callback Cursor~iteratorCallback
+ * @param {Object} doc An emitted document for the iterator
+ */
+
+/**
+ * The callback error format for the forEach iterator method
+ * @callback Cursor~endCallback
+ * @param {MongoError} error An error instance representing the error during the execution.
+ */
+
+/**
+ * Iterates over all the documents for this cursor using the iterator, callback pattern.
+ * @method
+ * @param {Cursor~iteratorCallback} iterator The iteration callback.
+ * @param {Cursor~endCallback} callback The end callback.
+ * @throws {MongoError}
+ * @return {null}
+ */
+Cursor.prototype.forEach = function(iterator, callback) {
+ this.each(function(err, doc){
+ if(err) { callback(err); return false; }
+ if(doc != null) { iterator(doc); return true; }
+ if(doc == null && callback) {
+ var internalCallback = callback;
+ callback = null;
+ internalCallback(null);
+ return false;
+ }
+ });
+}
+
+/**
+ * Set the ReadPreference for the cursor.
+ * @method
+ * @param {(string|ReadPreference)} readPreference The new read preference for the cursor.
+ * @throws {MongoError}
+ * @return {Cursor}
+ */
+Cursor.prototype.setReadPreference = function(r) {
+ if(this.s.state != Cursor.INIT) throw new MongoError('cannot change cursor readPreference after cursor has been accessed');
+ if(r instanceof ReadPreference) {
+ this.s.options.readPreference = new CoreReadPreference(r.mode, r.tags);
+ } else {
+ this.s.options.readPreference = new CoreReadPreference(r);
+ }
+
+ return this;
+}
+
+/**
+ * The callback format for results
+ * @callback Cursor~toArrayResultCallback
+ * @param {MongoError} error An error instance representing the error during the execution.
+ * @param {object[]} documents All the documents the satisfy the cursor.
+ */
+
+/**
+ * Returns an array of documents. The caller is responsible for making sure that there
+ * is enough memory to store the results. Note that the array only contain partial
+ * results when this cursor had been previouly accessed. In that case,
+ * cursor.rewind() can be used to reset the cursor.
+ * @method
+ * @param {Cursor~toArrayResultCallback} callback The result callback.
+ * @throws {MongoError}
+ * @return {null}
+ */
+Cursor.prototype.toArray = function(callback) {
+ var self = this;
+ if(!callback) throw new MongoError('callback is mandatory');
+ if(self.s.options.tailable) return handleCallback(callback, new MongoError("Tailable cursor cannot be converted to array"), null);
+ var items = [];
+
+ // Reset cursor
+ this.rewind();
+ self.s.state = Cursor.INIT;
+
+ // Fetch all the documents
+ var fetchDocs = function() {
+ self.next(function(err, doc) {
+ if(err) return handleCallback(callback, err);
+ if(doc == null) {
+ self.s.state = Cursor.CLOSED;
+ return handleCallback(callback, null, items);
+ }
+
+ // Add doc to items
+ items.push(doc)
+ // Get all buffered objects
+ if(self.bufferedCount() > 0) {
+ var a = self.readBufferedDocuments(self.bufferedCount())
+ items = items.concat(a);
+ }
+
+ // Attempt a fetch
+ fetchDocs();
+ })
+ }
+
+ fetchDocs();
+}
+
+/**
+ * The callback format for results
+ * @callback Cursor~countResultCallback
+ * @param {MongoError} error An error instance representing the error during the execution.
+ * @param {number} count The count of documents.
+ */
+
+/**
+ * Get the count of documents for this cursor
+ * @method
+ * @param {boolean} applySkipLimit Should the count command apply limit and skip settings on the cursor or in the passed in options.
+ * @param {object} [options=null] Optional settings.
+ * @param {number} [options.skip=null] The number of documents to skip.
+ * @param {number} [options.limit=null] The maximum amounts to count before aborting.
+ * @param {number} [options.maxTimeMS=null] Number of miliseconds to wait before aborting the query.
+ * @param {string} [options.hint=null] An index name hint for the query.
+ * @param {(ReadPreference|string)} [options.readPreference=null] The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).
+ * @param {Cursor~countResultCallback} callback The result callback.
+ * @return {null}
+ */
+Cursor.prototype.count = function(applySkipLimit, opts, callback) {
+ var self = this;
+ if(typeof opts == 'function') callback = opts, opts = {};
+ opts = opts || {};
+ if(self.s.cmd.query == null) callback(new MongoError("count can only be used with find command"));
+ if(typeof applySkipLimit == 'function') {
+ callback = applySkipLimit;
+ applySkipLimit = true;
+ }
+
+ var opts = {};
+ if(applySkipLimit) {
+ if(typeof this.cursorSkip() == 'number') opts.skip = this.cursorSkip();
+ if(typeof this.cursorLimit() == 'number') opts.limit = this.cursorLimit();
+ }
+
+ // Command
+
+ var delimiter = self.s.ns.indexOf('.');
+
+ var command = {
+ 'count': self.s.ns.substr(delimiter+1), 'query': self.s.cmd.query
+ }
+
+ // If maxTimeMS set
+ if(typeof maxTimeMS == 'number') {
+ command.maxTimeMS = self.s.maxTimeMS;
+ }
+
+ // Get a server
+ var server = self.s.topology.getServer(opts);
+ // Get a connection
+ var connection = self.s.topology.getConnection(opts);
+ // Get the callbacks
+ var callbacks = server.getCallbacks();
+
+ // Merge in any options
+ if(opts.skip) command.skip = opts.skip;
+ if(opts.limit) command.limit = opts.limit;
+ if(self.s.options.hint) command.hint = self.s.options.hint;
+
+ // Build Query object
+ var query = new Query(self.s.bson, f("%s.$cmd", self.s.ns.substr(0, delimiter)), command, {
+ numberToSkip: 0, numberToReturn: -1
+ , checkKeys: false
+ });
+
+ // Set up callback
+ callbacks.register(query.requestId, function(err, result) {
+ if(err) return handleCallback(callback, err);
+ if(result.documents.length == 1
+ && (result.documents[0].errmsg
+ || result.documents[0].err
+ || result.documents[0]['$err'])) return callback(MongoError.create(result.documents[0]));
+ handleCallback(callback, null, result.documents[0].n);
+ });
+
+ // Write the initial command out
+ connection.write(query.toBin());
+};
+
+/**
+ * Close the cursor, sending a KillCursor command and emitting close.
+ * @method
+ * @param {Cursor~resultCallback} [callback] The result callback.
+ * @return {null}
+ */
+Cursor.prototype.close = function(callback) {
+ this.s.state = Cursor.CLOSED;
+ // Kill the cursor
+ this.kill();
+ // Emit the close event for the cursor
+ this.emit('close');
+ // Callback if provided
+ if(callback) return handleCallback(callback, null, this);
+}
+
+/**
+ * Is the cursor closed
+ * @method
+ * @return {boolean}
+ */
+Cursor.prototype.isClosed = function() {
+ return this.isDead();
+}
+
+Cursor.prototype.destroy = function(err) {
+ this.pause();
+ this.close();
+ if(err) this.emit('error', err);
+}
+
+/**
+ * Return a modified Readable stream including a possible transform method.
+ * @method
+ * @param {object} [options=null] Optional settings.
+ * @param {function} [options.transform=null] A transformation method applied to each document emitted by the stream.
+ * @return {Cursor}
+ */
+Cursor.prototype.stream = function(options) {
+ this.s.streamOptions = options || {};
+ return this;
+}
+
+/**
+ * Execute the explain for the cursor
+ * @method
+ * @param {Cursor~resultCallback} [callback] The result callback.
+ * @return {null}
+ */
+Cursor.prototype.explain = function(callback) {
+ this.s.cmd.explain = true;
+ this.next(callback);
+}
+
+Cursor.prototype._read = function(n) {
+ var self = this;
+ if(self.s.state == Cursor.CLOSED || self.isDead()) {
+ return self.push(null);
+ }
+
+ // Get the next item
+ self.nextObject(function(err, result) {
+ if(err) {
+ if(!self.isDead()) self.close();
+ if(self.listeners('error') && self.listeners('error').length > 0) {
+ self.emit('error', err);
+ }
+
+ // Emit end event
+ return self.emit('end');
+ }
+
+ // If we provided a transformation method
+ if(typeof self.s.streamOptions.transform == 'function' && result != null) {
+ return self.push(self.s.streamOptions.transform(result));
+ }
+
+ // Return the result
+ self.push(result);
+ });
+}
+
+Object.defineProperty(Cursor.prototype, 'namespace', {
+ enumerable: true,
+ get: function() {
+ if (!this || !this.s) {
+ return null;
+ }
+
+ // TODO: refactor this logic into core
+ var ns = this.s.ns || '';
+ var firstDot = ns.indexOf('.');
+ if (firstDot < 0) {
+ return {
+ database: this.s.ns,
+ collection: ''
+ };
+ }
+ return {
+ database: ns.substr(0, firstDot),
+ collection: ns.substr(firstDot + 1)
+ };
+ }
+});
+
+/**
+ * The read() method pulls some data out of the internal buffer and returns it. If there is no data available, then it will return null.
+ * @function external:Readable#read
+ * @param {number} size Optional argument to specify how much data to read.
+ * @return {(String | Buffer | null)}
+ */
+
+/**
+ * Call this function to cause the stream to return strings of the specified encoding instead of Buffer objects.
+ * @function external:Readable#setEncoding
+ * @param {string} encoding The encoding to use.
+ * @return {null}
+ */
+
+/**
+ * This method will cause the readable stream to resume emitting data events.
+ * @function external:Readable#resume
+ * @return {null}
+ */
+
+/**
+ * This method will cause a stream in flowing-mode to stop emitting data events. Any data that becomes available will remain in the internal buffer.
+ * @function external:Readable#pause
+ * @return {null}
+ */
+
+/**
+ * This method pulls all the data out of a readable stream, and writes it to the supplied destination, automatically managing the flow so that the destination is not overwhelmed by a fast readable stream.
+ * @function external:Readable#pipe
+ * @param {Writable} destination The destination for writing data
+ * @param {object} [options] Pipe options
+ * @return {null}
+ */
+
+/**
+ * This method will remove the hooks set up for a previous pipe() call.
+ * @function external:Readable#unpipe
+ * @param {Writable} [destination] The destination for writing data
+ * @return {null}
+ */
+
+/**
+ * This is useful in certain cases where a stream is being consumed by a parser, which needs to "un-consume" some data that it has optimistically pulled out of the source, so that the stream can be passed on to some other party.
+ * @function external:Readable#unshift
+ * @param {(Buffer|string)} chunk Chunk of data to unshift onto the read queue.
+ * @return {null}
+ */
+
+/**
+ * Versions of Node prior to v0.10 had streams that did not implement the entire Streams API as it is today. (See "Compatibility" below for more information.)
+ * @function external:Readable#wrap
+ * @param {Stream} stream An "old style" readable stream.
+ * @return {null}
+ */
+
+Cursor.INIT = 0;
+Cursor.OPEN = 1;
+Cursor.CLOSED = 2;
+Cursor.GET_MORE = 3;
+
+module.exports = Cursor;
diff --git a/server/node_modules/mongodb/lib/db.js b/server/node_modules/mongodb/lib/db.js
new file mode 100755
index 00000000..a3a05064
--- /dev/null
+++ b/server/node_modules/mongodb/lib/db.js
@@ -0,0 +1,1352 @@
+"use strict";
+
+var EventEmitter = require('events').EventEmitter
+ , inherits = require('util').inherits
+ , getSingleProperty = require('./utils').getSingleProperty
+ , shallowClone = require('./utils').shallowClone
+ , parseIndexOptions = require('./utils').parseIndexOptions
+ , debugOptions = require('./utils').debugOptions
+ , CommandCursor = require('./command_cursor')
+ , handleCallback = require('./utils').handleCallback
+ , toError = require('./utils').toError
+ , ReadPreference = require('./read_preference')
+ , f = require('util').format
+ , Admin = require('./admin')
+ , Code = require('mongodb-core').BSON.Code
+ , CoreReadPreference = require('mongodb-core').ReadPreference
+ , MongoError = require('mongodb-core').MongoError
+ , ObjectID = require('mongodb-core').ObjectID
+ , Logger = require('mongodb-core').Logger
+ , Collection = require('./collection')
+ , crypto = require('crypto');
+
+var debugFields = ['authSource', 'w', 'wtimeout', 'j', 'native_parser', 'forceServerObjectId'
+ , 'serializeFunctions', 'raw', 'promoteLongs', 'bufferMaxEntries', 'numberOfRetries', 'retryMiliSeconds'
+ , 'readPreference', 'pkFactory'];
+
+/**
+ * @fileOverview The **Db** class is a class that represents a MongoDB Database.
+ *
+ * @example
+ * var MongoClient = require('mongodb').MongoClient,
+ * test = require('assert');
+ * // Connection url
+ * var url = 'mongodb://localhost:27017/test';
+ * // Connect using MongoClient
+ * MongoClient.connect(url, function(err, db) {
+ * // Get an additional db
+ * var testDb = db.db('test');
+ * db.close();
+ * });
+ */
+
+/**
+ * Creates a new Db instance
+ * @class
+ * @param {string} databaseName The name of the database this instance represents.
+ * @param {(Server|ReplSet|Mongos)} topology The server topology for the database.
+ * @param {object} [options=null] Optional settings.
+ * @param {string} [options.authSource=null] If the database authentication is dependent on another databaseName.
+ * @param {(number|string)} [options.w=null] The write concern.
+ * @param {number} [options.wtimeout=null] The write concern timeout.
+ * @param {boolean} [options.j=false] Specify a journal write concern.
+ * @param {boolean} [options.native_parser=true] Select C++ bson parser instead of JavaScript parser.
+ * @param {boolean} [options.forceServerObjectId=false] Force server to assign _id values instead of driver.
+ * @param {boolean} [options.serializeFunctions=false] Serialize functions on any object.
+ * @param {boolean} [options.raw=false] Return document results as raw BSON buffers.
+ * @param {boolean} [options.promoteLongs=true] Promotes Long values to number if they fit inside the 53 bits resolution.
+ * @param {number} [options.bufferMaxEntries=-1] Sets a cap on how many operations the driver will buffer up before giving up on getting a working connection, default is -1 which is unlimited.
+ * @param {number} [options.numberOfRetries=5] Number of retries off connection.
+ * @param {number} [options.retryMiliSeconds=500] Number of milliseconds between retries.
+ * @param {(ReadPreference|string)} [options.readPreference=null] The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).
+ * @param {object} [options.pkFactory=null] A primary key factory object for generation of custom _id keys.
+ * @property {(Server|ReplSet|Mongos)} serverConfig Get the current db topology.
+ * @property {number} bufferMaxEntries Current bufferMaxEntries value for the database
+ * @property {string} databaseName The name of the database this instance represents.
+ * @property {object} options The options associated with the db instance.
+ * @property {boolean} native_parser The current value of the parameter native_parser.
+ * @property {boolean} slaveOk The current slaveOk value for the db instance.
+ * @property {object} writeConcern The current write concern values.
+ * @fires Db#close
+ * @fires Db#authenticated
+ * @fires Db#reconnect
+ * @fires Db#error
+ * @fires Db#timeout
+ * @fires Db#parseError
+ * @fires Db#fullsetup
+ * @return {Db} a Db instance.
+ */
+var Db = function(databaseName, topology, options) {
+ options = options || {};
+ if(!(this instanceof Db)) return new Db(databaseName, topology, options);
+ EventEmitter.call(this);
+ var self = this;
+ // var self = this; // Internal state of the db object
+ this.s = {
+ // Database name
+ databaseName: databaseName
+ // Topology
+ , topology: topology
+ // Options
+ , options: options
+ // Logger instance
+ , logger: Logger('Db', options)
+ // Get the bson parser
+ , bson: topology ? topology.bson : null
+ // Authsource if any
+ , authSource: options.authSource
+ // Unpack read preference
+ , readPreference: options.readPreference
+ // Set buffermaxEntries
+ , bufferMaxEntries: typeof options.bufferMaxEntries == 'number' ? options.bufferMaxEntries : -1
+ // Parent db (if chained)
+ , parentDb: options.parentDb || null
+ // Set up the primary key factory or fallback to ObjectID
+ , pkFactory: options.pkFactory || ObjectID
+ // Get native parser
+ , nativeParser: options.nativeParser || options.native_parser
+ }
+
+ // Ensure we have a valid db name
+ validateDatabaseName(self.s.databaseName);
+
+ // If we have specified the type of parser
+ if(typeof self.s.nativeParser == 'boolean') {
+ if(self.s.nativeParser) {
+ topology.setBSONParserType("c++");
+ } else {
+ topology.setBSONParserType("js");
+ }
+ }
+
+ // Add a read Only property
+ getSingleProperty(this, 'serverConfig', self.s.topology);
+ getSingleProperty(this, 'bufferMaxEntries', self.s.bufferMaxEntries);
+ getSingleProperty(this, 'databaseName', self.s.databaseName);
+
+ // Last ismaster
+ Object.defineProperty(this, 'options', {
+ enumerable:true,
+ get: function() { return self.s.options; }
+ });
+
+ // Last ismaster
+ Object.defineProperty(this, 'native_parser', {
+ enumerable:true,
+ get: function() { return self.s.topology.parserType() == 'c++'; }
+ });
+
+ // Last ismaster
+ Object.defineProperty(this, 'slaveOk', {
+ enumerable:true,
+ get: function() {
+ if(self.s.options.readPreference != null
+ && (self.s.options.readPreference != 'primary' || self.s.options.readPreference.mode != 'primary')) {
+ return true;
+ }
+ return false;
+ }
+ });
+
+ Object.defineProperty(this, 'writeConcern', {
+ enumerable:true,
+ get: function() {
+ var ops = {};
+ if(self.s.options.w != null) ops.w = self.s.options.w;
+ if(self.s.options.j != null) ops.j = self.s.options.j;
+ if(self.s.options.fsync != null) ops.fsync = self.s.options.fsync;
+ if(self.s.options.wtimeout != null) ops.wtimeout = self.s.options.wtimeout;
+ return ops;
+ }
+ });
+
+ topology.once('error', createListener(self, 'error', self));
+ topology.once('timeout', createListener(self, 'timeout', self));
+ topology.once('close', createListener(self, 'close', self));
+ topology.once('parseError', createListener(self, 'parseError', self));
+ topology.once('open', createListener(self, 'open', self));
+ topology.once('fullsetup', createListener(self, 'fullsetup', self));
+ topology.once('all', createListener(self, 'all', self));
+ topology.on('reconnect', createListener(self, 'reconnect', self));
+}
+
+inherits(Db, EventEmitter);
+
+/**
+ * The callback format for the Db.open method
+ * @callback Db~openCallback
+ * @param {MongoError} error An error instance representing the error during the execution.
+ * @param {Db} db The Db instance if the open method was successful.
+ */
+
+/**
+ * Open the database
+ * @method
+ * @param {Db~openCallback} callback Callback
+ * @return {null}
+ */
+Db.prototype.open = function(callback) {
+ var self = this;
+ self.s.topology.connect(self, self.s.options, function(err, topology) {
+ if(callback == null) return;
+ var internalCallback = callback;
+ callback == null;
+
+ if(err) {
+ self.close();
+ return internalCallback(err);
+ }
+
+ internalCallback(null, self);
+ });
+}
+
+/**
+ * The callback format for results
+ * @callback Db~resultCallback
+ * @param {MongoError} error An error instance representing the error during the execution.
+ * @param {object} result The result object if the command was executed successfully.
+ */
+
+/**
+ * Execute a command
+ * @method
+ * @param {object} command The command hash
+ * @param {object} [options=null] Optional settings.
+ * @param {(ReadPreference|string)} [options.readPreference=null] The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).
+ * @param {number} [options.maxTimeMS=null] Number of milliseconds to wait before aborting the query.
+ * @param {Db~resultCallback} callback The command result callback
+ * @return {null}
+ */
+Db.prototype.command = function(command, options, callback) {
+ var self = this;
+ if(typeof options == 'function') callback = options, options = {};
+ var dbName = options.dbName || options.authdb || self.s.databaseName;
+ // Clone the options
+ options = shallowClone(options);
+ // If we have a readPreference set
+ if(options.readPreference == null && self.s.readPreference) {
+ options.readPreference = self.s.readPreference;
+ }
+
+ // Convert the readPreference
+ if(options.readPreference && typeof options.readPreference == 'string') {
+ options.readPreference = new CoreReadPreference(options.readPreference);
+ } else if(options.readPreference instanceof ReadPreference) {
+ options.readPreference = new CoreReadPreference(options.readPreference.mode
+ , options.readPreference.tags);
+ }
+
+ // Debug information
+ if(self.s.logger.isDebug()) self.s.logger.debug(f('executing command %s against %s with options [%s]'
+ , JSON.stringify(command), f('%s.$cmd', dbName), JSON.stringify(debugOptions(debugFields, options))));
+
+ // Execute command
+ self.s.topology.command(f('%s.$cmd', dbName), command, options, function(err, result) {
+ if(err) return handleCallback(callback, err);
+ handleCallback(callback, null, result.result);
+ });
+}
+
+/**
+ * The callback format for results
+ * @callback Db~noResultCallback
+ * @param {MongoError} error An error instance representing the error during the execution.
+ * @param {null} result Is not set to a value
+ */
+
+/**
+ * Close the db and it's underlying connections
+ * @method
+ * @param {boolean} force Force close, emitting no events
+ * @param {Db~noResultCallback} callback The result callback
+ * @return {null}
+ */
+Db.prototype.close = function(force, callback) {
+ if(typeof force == 'function') callback = force, force = false;
+ this.s.topology.close(force);
+ if(this.listeners('close').length > 0) this.emit('close');
+ this.removeAllListeners('close');
+ if(this.s.parentDb) this.s.parentDb.close();
+ if(typeof callback == 'function') handleCallback(callback, null);
+}
+
+/**
+ * Return the Admin db instance
+ * @method
+ * @return {Admin} return the new Admin db instance
+ */
+Db.prototype.admin = function() {
+ return new Admin(this, this.s.topology);
+};
+
+/**
+ * The callback format for the collection method, must be used if strict is specified
+ * @callback Db~collectionResultCallback
+ * @param {MongoError} error An error instance representing the error during the execution.
+ * @param {Collection} collection The collection instance.
+ */
+
+/**
+ * Fetch a specific collection (containing the actual collection information). If the application does not use strict mode you can
+ * can use it without a callback in the following way. var collection = db.collection('mycollection');
+ *
+ * @method
+ * @param {string} name the collection name we wish to access.
+ * @param {object} [options=null] Optional settings.
+ * @param {(number|string)} [options.w=null] The write concern.
+ * @param {number} [options.wtimeout=null] The write concern timeout.
+ * @param {boolean} [options.j=false] Specify a journal write concern.
+ * @param {boolean} [options.raw=false] Return document results as raw BSON buffers.
+ * @param {object} [options.pkFactory=null] A primary key factory object for generation of custom _id keys.
+ * @param {(ReadPreference|string)} [options.readPreference=null] The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).
+ * @param {boolean} [options.serializeFunctions=false] Serialize functions on any object.
+ * @param {boolean} [options.strict=false] Returns an error if the collection does not exist
+ * @param {Db~collectionResultCallback} callback The collection result callback
+ * @return {Collection} return the new Collection instance if not in strict mode
+ */
+Db.prototype.collection = function(name, options, callback) {
+ var self = this;
+ if(typeof options == 'function') callback = options, options = {};
+ options = options || {};
+
+ if(options == null || !options.strict) {
+ try {
+ var collection = new Collection(this, this.s.topology, this.s.databaseName, name, this.s.pkFactory, options);
+ if(callback) callback(null, collection);
+ return collection;
+ } catch(err) {
+ if(callback) return callback(err);
+ throw err;
+ }
+ }
+
+ // Strict mode
+ if(typeof callback != 'function') {
+ throw toError(f("A callback is required in strict mode. While getting collection %s.", name));
+ }
+
+ // Strict mode
+ this.listCollections({name:name}).toArray(function(err, collections) {
+ if(err != null) return handleCallback(callback, err, null);
+ if(collections.length == 0) return handleCallback(callback, toError(f("Collection %s does not exist. Currently in strict mode.", name)), null);
+
+ try {
+ return handleCallback(callback, null, new Collection(self, self.s.topology, self.s.databaseName, name, self.s.pkFactory, options));
+ } catch(err) {
+ return handleCallback(callback, err, null);
+ }
+ });
+}
+
+/**
+ * Creates a collection on a server pre-allocating space, need to create f.ex capped collections.
+ *
+ * @method
+ * @param {string} name the collection name we wish to access.
+ * @param {object} [options=null] Optional settings.
+ * @param {(number|string)} [options.w=null] The write concern.
+ * @param {number} [options.wtimeout=null] The write concern timeout.
+ * @param {boolean} [options.j=false] Specify a journal write concern.
+ * @param {boolean} [options.raw=false] Return document results as raw BSON buffers.
+ * @param {object} [options.pkFactory=null] A primary key factory object for generation of custom _id keys.
+ * @param {(ReadPreference|string)} [options.readPreference=null] The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).
+ * @param {boolean} [options.serializeFunctions=false] Serialize functions on any object.
+ * @param {boolean} [options.strict=false] Returns an error if the collection does not exist
+ * @param {boolean} [options.capped=false] Create a capped collection.
+ * @param {number} [options.size=null] The size of the capped collection in bytes.
+ * @param {number} [options.max=null] The maximum number of documents in the capped collection.
+ * @param {boolean} [options.autoIndexId=true] Create an index on the _id field of the document, True by default on MongoDB 2.2 or higher off for version < 2.2.
+ * @param {Db~collectionResultCallback} callback The results callback
+ * @return {null}
+ */
+Db.prototype.createCollection = function(name, options, callback) {
+ var self = this;
+ var args = Array.prototype.slice.call(arguments, 0);
+ callback = args.pop();
+ name = args.length ? args.shift() : null;
+ options = args.length ? args.shift() || {} : {};
+
+ // Get the write concern options
+ var finalOptions = writeConcern(shallowClone(options), this, options);
+
+ // Check if we have the name
+ this.listCollections({name: name}).toArray(function(err, collections) {
+ if(err != null) return handleCallback(callback, err, null);
+ if(collections.length > 0 && finalOptions.strict) {
+ return handleCallback(callback, new MongoError(f("Collection %s already exists. Currently in strict mode.", name)), null);
+ } else if (collections.length > 0) {
+ try { return handleCallback(callback, null, new Collection(self, self.s.topology, self.s.databaseName, name, self.s.pkFactory, options)); }
+ catch(err) { return handleCallback(callback, err); }
+ }
+
+ // Create collection command
+ var cmd = {'create':name};
+
+ // Add all optional parameters
+ for(var n in options) {
+ if(options[n] != null && typeof options[n] != 'function')
+ cmd[n] = options[n];
+ }
+
+ // Execute command
+ self.command(cmd, finalOptions, function(err, result) {
+ if(err) return handleCallback(callback, err);
+ handleCallback(callback, null, new Collection(self, self.s.topology, self.s.databaseName, name, self.s.pkFactory, options));
+ });
+ });
+}
+
+/**
+ * Get all the db statistics.
+ *
+ * @method
+ * @param {object} [options=null] Optional settings.
+ * @param {number} [options.scale=null] Divide the returned sizes by scale value.
+ * @param {Db~resultCallback} callback The collection result callback
+ * @return {null}
+ */
+Db.prototype.stats = function(options, callback) {
+ if(typeof options == 'function') callback = options, options = {};
+ options = options || {};
+ // Build command object
+ var commandObject = { dbStats:true };
+ // Check if we have the scale value
+ if(options['scale'] != null) commandObject['scale'] = options['scale'];
+ // Execute the command
+ this.command(commandObject, options, callback);
+}
+
+// Transformation methods for cursor results
+var listCollectionsTranforms = function(databaseName) {
+ var matching = f('%s.', databaseName);
+
+ return {
+ doc: function(doc) {
+ var index = doc.name.indexOf(matching);
+ // Remove database name if available
+ if(doc.name && index == 0) {
+ doc.name = doc.name.substr(index + matching.length);
+ }
+
+ return doc;
+ }
+ }
+}
+
+/**
+ * Get the list of all collection information for the specified db.
+ *
+ * @method
+ * @param {object} filter Query to filter collections by
+ * @param {object} [options=null] Optional settings.
+ * @param {number} [options.batchSize=null] The batchSize for the returned command cursor or if pre 2.8 the systems batch collection
+ * @return {CommandCursor}
+ */
+Db.prototype.listCollections = function(filter, options) {
+ filter = filter || {};
+ options = options || {};
+
+ // We have a list collections command
+ if(this.serverConfig.capabilities().hasListCollectionsCommand) {
+ // Cursor options
+ var cursor = options.batchSize ? {batchSize: options.batchSize} : {}
+ // Build the command
+ var command = { listCollections : true, filter: filter, cursor: cursor };
+ // Set the AggregationCursor constructor
+ options.cursorFactory = CommandCursor;
+ // Filter out the correct field values
+ options.transforms = listCollectionsTranforms(this.s.databaseName);
+ // Execute the cursor
+ return this.s.topology.cursor(f('%s.$cmd', this.s.databaseName), command, options);
+ }
+
+ // We cannot use the listCollectionsCommand
+ if(!this.serverConfig.capabilities().hasListCollectionsCommand) {
+ // If we have legacy mode and have not provided a full db name filter it
+ if(typeof filter.name == 'string' && !(new RegExp('^' + this.databaseName + '\\.').test(filter.name))) {
+ filter = shallowClone(filter);
+ filter.name = f('%s.%s', this.s.databaseName, filter.name);
+ }
+ }
+
+ // No filter, filter by current database
+ if(filter == null) {
+ filter.name = f('/%s/', this.s.databaseName);
+ }
+
+ // Rewrite the filter to use $and to filter out indexes
+ if(filter.name) {
+ filter = {$and: [{name: filter.name}, {name:/^((?!\$).)*$/}]};
+ } else {
+ filter = {name:/^((?!\$).)*$/};
+ }
+
+ // Return options
+ var options = {transforms: listCollectionsTranforms(this.s.databaseName)}
+ // Get the cursor
+ var cursor = this.collection(Db.SYSTEM_NAMESPACE_COLLECTION).find(filter, options);
+ // Set the passed in batch size if one was provided
+ if(options.batchSize) cursor = cursor.batchSize(options.batchSize);
+ // We have a fallback mode using legacy systems collections
+ return cursor;
+};
+
+/**
+ * Evaluate JavaScript on the server
+ *
+ * @method
+ * @param {Code} code JavaScript to execute on server.
+ * @param {(object|array)} parameters The parameters for the call.
+ * @param {object} [options=null] Optional settings.
+ * @param {boolean} [options.nolock=false] Tell MongoDB not to block on the evaulation of the javascript.
+ * @param {Db~resultCallback} callback The results callback
+ * @return {null}
+ */
+Db.prototype.eval = function(code, parameters, options, callback) {
+ var self = this;
+ var args = Array.prototype.slice.call(arguments, 1);
+ callback = args.pop();
+ parameters = args.length ? args.shift() : parameters;
+ options = args.length ? args.shift() || {} : {};
+
+ var finalCode = code;
+ var finalParameters = [];
+
+ // If not a code object translate to one
+ if(!(finalCode instanceof Code)) finalCode = new Code(finalCode);
+ // Ensure the parameters are correct
+ if(parameters != null && !Array.isArray(parameters) && typeof parameters !== 'function') {
+ finalParameters = [parameters];
+ } else if(parameters != null && Array.isArray(parameters) && typeof parameters !== 'function') {
+ finalParameters = parameters;
+ }
+
+ // Create execution selector
+ var cmd = {'$eval':finalCode, 'args':finalParameters};
+ // Check if the nolock parameter is passed in
+ if(options['nolock']) {
+ cmd['nolock'] = options['nolock'];
+ }
+
+ // Set primary read preference
+ options.readPreference = new CoreReadPreference(ReadPreference.PRIMARY);
+
+ // Execute the command
+ self.command(cmd, options, function(err, result) {
+ if(err) return handleCallback(callback, err, null);
+ if(result && result.ok == 1) return handleCallback(callback, null, result.retval);
+ if(result) return handleCallback(callback, new MongoError(f("eval failed: %s", result.errmsg)), null);
+ handleCallback(callback, err, result);
+ });
+};
+
+/**
+ * Rename a collection.
+ *
+ * @method
+ * @param {string} fromCollection Name of current collection to rename.
+ * @param {string} toCollection New name of of the collection.
+ * @param {object} [options=null] Optional settings.
+ * @param {boolean} [options.dropTarget=false] Drop the target name collection if it previously exists.
+ * @param {Db~collectionResultCallback} callback The results callback
+ * @return {null}
+ */
+Db.prototype.renameCollection = function(fromCollection, toCollection, options, callback) {
+ if(typeof options == 'function') callback = options, options = {};
+ // Add return new collection
+ options.new_collection = true;
+ // Execute using the collection method
+ this.collection(fromCollection).rename(toCollection, options, callback);
+};
+
+/**
+ * Drop a collection from the database, removing it permanently. New accesses will create a new collection.
+ *
+ * @method
+ * @param {string} name Name of collection to drop
+ * @param {Db~resultCallback} callback The results callback
+ * @return {null}
+ */
+Db.prototype.dropCollection = function(name, callback) {
+ callback || (callback = function(){});
+
+ // Command to execute
+ var cmd = {'drop':name}
+
+ // Execute command
+ this.command(cmd, this.s.options, function(err, result) {
+ if(err) return handleCallback(callback, err);
+ if(result.ok) return handleCallback(callback, null, true);
+ handleCallback(callback, null, false);
+ });
+};
+
+/**
+ * Drop a database.
+ *
+ * @method
+ * @param {Db~resultCallback} [callback] The results callback
+ * @return {null}
+ */
+Db.prototype.dropDatabase = function(callback) {
+ if(typeof options == 'function') callback = options, options = {};
+ // Drop database command
+ var cmd = {'dropDatabase':1};
+
+ // Execute the command
+ this.command(cmd, this.s.options, function(err, result) {
+ if(callback == null) return;
+ if(err) return handleCallback(callback, err, null);
+ handleCallback(callback, null, result.ok ? true : false);
+ });
+}
+
+/**
+ * The callback format for the collections method.
+ * @callback Db~collectionsResultCallback
+ * @param {MongoError} error An error instance representing the error during the execution.
+ * @param {Collection[]} collections An array of all the collections objects for the db instance.
+ */
+
+/**
+ * Fetch all collections for the current db.
+ *
+ * @method
+ * @param {Db~collectionsResultCallback} [callback] The results callback
+ * @return {null}
+ */
+Db.prototype.collections = function(callback) {
+ var self = this;
+ // Let's get the collection names
+ this.listCollections().toArray(function(err, documents) {
+ if(err != null) return handleCallback(callback, err, null);
+ // Filter collections removing any illegal ones
+ documents = documents.filter(function(doc) {
+ return doc.name.indexOf('$') == -1;
+ });
+
+ // Return the collection objects
+ handleCallback(callback, null, documents.map(function(d) {
+ return new Collection(self, self.s.topology, self.s.databaseName, d.name.replace(self.s.databaseName + ".", ''), self.s.pkFactory, self.s.options);
+ }));
+ });
+};
+
+/**
+ * Runs a command on the database as admin.
+ * @method
+ * @param {object} command The command hash
+ * @param {object} [options=null] Optional settings.
+ * @param {(ReadPreference|string)} [options.readPreference=null] The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).
+ * @param {number} [options.maxTimeMS=null] Number of milliseconds to wait before aborting the query.
+ * @param {Db~resultCallback} callback The command result callback
+ * @return {null}
+ */
+Db.prototype.executeDbAdminCommand = function(selector, options, callback) {
+ if(typeof options == 'function') callback = options, options = {};
+ if(options.readPreference) {
+ options.readPreference = options.readPreference;
+ }
+
+ // Execute command
+ this.s.topology.command('admin.$cmd', selector, options, function(err, result) {
+ if(err) return handleCallback(callback, err);
+ handleCallback(callback, null, result.result);
+ });
+};
+
+/**
+ * Creates an index on the db and collection collection.
+ * @method
+ * @param {string} name Name of the collection to create the index on.
+ * @param {(string|object)} fieldOrSpec Defines the index.
+ * @param {object} [options=null] Optional settings.
+ * @param {(number|string)} [options.w=null] The write concern.
+ * @param {number} [options.wtimeout=null] The write concern timeout.
+ * @param {boolean} [options.j=false] Specify a journal write concern.
+ * @param {boolean} [options.unique=false] Creates an unique index.
+ * @param {boolean} [options.sparse=false] Creates a sparse index.
+ * @param {boolean} [options.background=false] Creates the index in the background, yielding whenever possible.
+ * @param {boolean} [options.dropDups=false] A unique index cannot be created on a key that has pre-existing duplicate values. If you would like to create the index anyway, keeping the first document the database indexes and deleting all subsequent documents that have duplicate value
+ * @param {number} [options.min=null] For geospatial indexes set the lower bound for the co-ordinates.
+ * @param {number} [options.max=null] For geospatial indexes set the high bound for the co-ordinates.
+ * @param {number} [options.v=null] Specify the format version of the indexes.
+ * @param {number} [options.expireAfterSeconds=null] Allows you to expire data on indexes applied to a data (MongoDB 2.2 or higher)
+ * @param {number} [options.name=null] Override the autogenerated index name (useful if the resulting name is larger than 128 bytes)
+ * @param {Db~resultCallback} callback The command result callback
+ * @return {null}
+ */
+Db.prototype.createIndex = function(name, fieldOrSpec, options, callback) {
+ var self = this;
+ var args = Array.prototype.slice.call(arguments, 2);
+ callback = args.pop();
+ options = args.length ? args.shift() || {} : {};
+ options = typeof callback === 'function' ? options : callback;
+ options = options == null ? {} : options;
+
+ // Get the write concern options
+ var finalOptions = writeConcern({}, self, options);
+ // Ensure we have a callback
+ if(finalOptions.writeConcern && typeof callback != 'function') {
+ throw new MongoError("Cannot use a writeConcern without a provided callback");
+ }
+
+ // Shallow clone the options
+ options = shallowClone(options);
+
+ // Always set read preference to primary
+ options.readPreference = ReadPreference.PRIMARY;
+
+ // Attempt to run using createIndexes command
+ createIndexUsingCreateIndexes(self, name, fieldOrSpec, options, function(err, result) {
+ if(err == null) return handleCallback(callback, err, result);
+ // Create command
+ var doc = createCreateIndexCommand(self, name, fieldOrSpec, options);
+ // Set no key checking
+ finalOptions.checkKeys = false;
+ // Insert document
+ self.s.topology.insert(f("%s.%s", self.s.databaseName, Db.SYSTEM_INDEX_COLLECTION), doc, finalOptions, function(err, result) {
+ if(callback == null) return;
+ if(err) return handleCallback(callback, err);
+ if(result == null) return handleCallback(callback, null, null);
+ if(result.result.writeErrors) return handleCallback(callback, MongoError.create(result.result.writeErrors[0]), null);
+ handleCallback(callback, null, doc.name);
+ });
+ });
+};
+
+/**
+ * Ensures that an index exists, if it does not it creates it
+ * @method
+ * @deprecated since version 2.0
+ * @param {string} name The index name
+ * @param {(string|object)} fieldOrSpec Defines the index.
+ * @param {object} [options=null] Optional settings.
+ * @param {(number|string)} [options.w=null] The write concern.
+ * @param {number} [options.wtimeout=null] The write concern timeout.
+ * @param {boolean} [options.j=false] Specify a journal write concern.
+ * @param {boolean} [options.unique=false] Creates an unique index.
+ * @param {boolean} [options.sparse=false] Creates a sparse index.
+ * @param {boolean} [options.background=false] Creates the index in the background, yielding whenever possible.
+ * @param {boolean} [options.dropDups=false] A unique index cannot be created on a key that has pre-existing duplicate values. If you would like to create the index anyway, keeping the first document the database indexes and deleting all subsequent documents that have duplicate value
+ * @param {number} [options.min=null] For geospatial indexes set the lower bound for the co-ordinates.
+ * @param {number} [options.max=null] For geospatial indexes set the high bound for the co-ordinates.
+ * @param {number} [options.v=null] Specify the format version of the indexes.
+ * @param {number} [options.expireAfterSeconds=null] Allows you to expire data on indexes applied to a data (MongoDB 2.2 or higher)
+ * @param {number} [options.name=null] Override the autogenerated index name (useful if the resulting name is larger than 128 bytes)
+ * @param {Db~resultCallback} callback The command result callback
+ * @return {null}
+ */
+Db.prototype.ensureIndex = function(name, fieldOrSpec, options, callback) {
+ var self = this;
+ if(typeof options == 'function') callback = options, options = {};
+ options = options || {};
+
+ // Get the write concern options
+ var finalOptions = writeConcern({}, self, options);
+ // Create command
+ var selector = createCreateIndexCommand(self, name, fieldOrSpec, options);
+ var index_name = selector.name;
+
+ // Default command options
+ var commandOptions = {};
+ // Check if the index allready exists
+ this.indexInformation(name, finalOptions, function(err, indexInformation) {
+ if(err != null && err.code != 26) return handleCallback(callback, err, null);
+ // If the index does not exist, create it
+ if(indexInformation == null || !indexInformation[index_name]) {
+ self.createIndex(name, fieldOrSpec, options, callback);
+ } else {
+ if(typeof callback === 'function') return handleCallback(callback, null, index_name);
+ }
+ });
+};
+
+/**
+ * Create a new Db instance sharing the current socket connections.
+ * @method
+ * @param {string} name The name of the database we want to use.
+ * @return {Db}
+ */
+Db.prototype.db = function(dbName) {
+ // Copy the options and add out internal override of the not shared flag
+ var options = {};
+ for(var key in this.options) {
+ options[key] = this.options[key];
+ }
+
+ // Add current db as parentDb
+ options.parentDb = this;
+
+ // Return the db object
+ var db = new Db(dbName, this.s.topology, options)
+ // Add listeners to the parent database
+ this.once('error', createListener(this, 'error', db));
+ this.once('timeout', createListener(this, 'timeout', db));
+ this.once('close', createListener(this, 'close', db));
+ this.once('parseError', createListener(this, 'parseError', db));
+ // Return the database
+ return db;
+};
+
+var _executeAuthCreateUserCommand = function(self, username, password, options, callback) {
+ // Special case where there is no password ($external users)
+ if(typeof username == 'string'
+ && password != null && typeof password == 'object') {
+ options = password;
+ password = null;
+ }
+
+ // Unpack all options
+ if(typeof options == 'function') {
+ callback = options;
+ options = {};
+ }
+
+ // Error out if we digestPassword set
+ if(options.digestPassword != null) {
+ throw toError("The digestPassword option is not supported via add_user. Please use db.command('createUser', ...) instead for this option.");
+ }
+
+ // Get additional values
+ var customData = options.customData != null ? options.customData : {};
+ var roles = Array.isArray(options.roles) ? options.roles : [];
+ var maxTimeMS = typeof options.maxTimeMS == 'number' ? options.maxTimeMS : null;
+
+ // If not roles defined print deprecated message
+ if(roles.length == 0) {
+ console.log("Creating a user without roles is deprecated in MongoDB >= 2.6");
+ }
+
+ // Get the error options
+ var commandOptions = {writeCommand:true};
+ if(options['dbName']) commandOptions.dbName = options['dbName'];
+
+ // Add maxTimeMS to options if set
+ if(maxTimeMS != null) commandOptions.maxTimeMS = maxTimeMS;
+
+ // Check the db name and add roles if needed
+ if((self.databaseName.toLowerCase() == 'admin' || options.dbName == 'admin') && !Array.isArray(options.roles)) {
+ roles = ['root']
+ } else if(!Array.isArray(options.roles)) {
+ roles = ['dbOwner']
+ }
+
+ // Build the command to execute
+ var command = {
+ createUser: username
+ , customData: customData
+ , roles: roles
+ , digestPassword:false
+ }
+
+ // Apply write concern to command
+ command = writeConcern(command, self, options);
+
+ // Use node md5 generator
+ var md5 = crypto.createHash('md5');
+ // Generate keys used for authentication
+ md5.update(username + ":mongo:" + password);
+ var userPassword = md5.digest('hex');
+
+ // No password
+ if(typeof password == 'string') {
+ command.pwd = userPassword;
+ }
+
+ // Force write using primary
+ commandOptions.readPreference = CoreReadPreference.primary;
+
+ // Execute the command
+ self.command(command, commandOptions, function(err, result) {
+ if(err && err.ok == 0 && err.code == undefined) return handleCallback(callback, {code: -5000}, null);
+ if(err) return handleCallback(callback, err, null);
+ handleCallback(callback, !result.ok ? toError(result) : null
+ , result.ok ? [{user: username, pwd: ''}] : null);
+ })
+}
+
+/**
+ * Add a user to the database.
+ * @method
+ * @param {string} username The username.
+ * @param {string} password The password.
+ * @param {object} [options=null] Optional settings.
+ * @param {(number|string)} [options.w=null] The write concern.
+ * @param {number} [options.wtimeout=null] The write concern timeout.
+ * @param {boolean} [options.j=false] Specify a journal write concern.
+ * @param {object} [options.customData=null] Custom data associated with the user (only Mongodb 2.6 or higher)
+ * @param {object[]} [options.roles=null] Roles associated with the created user (only Mongodb 2.6 or higher)
+ * @param {Db~resultCallback} callback The command result callback
+ * @return {null}
+ */
+Db.prototype.addUser = function(username, password, options, callback) {
+ // Unpack the parameters
+ var self = this;
+ var args = Array.prototype.slice.call(arguments, 2);
+ callback = args.pop();
+ options = args.length ? args.shift() || {} : {};
+
+ // Attempt to execute auth command
+ _executeAuthCreateUserCommand(this, username, password, options, function(err, r) {
+ // We need to perform the backward compatible insert operation
+ if(err && err.code == -5000) {
+ var finalOptions = writeConcern(shallowClone(options), self, options);
+ // Use node md5 generator
+ var md5 = crypto.createHash('md5');
+ // Generate keys used for authentication
+ md5.update(username + ":mongo:" + password);
+ var userPassword = md5.digest('hex');
+
+ // If we have another db set
+ var db = options.dbName ? self.db(options.dbName) : self;
+
+ // Fetch a user collection
+ var collection = db.collection(Db.SYSTEM_USER_COLLECTION);
+
+ // Check if we are inserting the first user
+ collection.count({}, function(err, count) {
+ // We got an error (f.ex not authorized)
+ if(err != null) return handleCallback(callback, err, null);
+ // Check if the user exists and update i
+ collection.find({user: username}, {dbName: options['dbName']}).toArray(function(err, documents) {
+ // We got an error (f.ex not authorized)
+ if(err != null) return handleCallback(callback, err, null);
+ // Add command keys
+ finalOptions.upsert = true;
+
+ // We have a user, let's update the password or upsert if not
+ collection.update({user: username},{$set: {user: username, pwd: userPassword}}, finalOptions, function(err, results, full) {
+ if(count == 0 && err) return handleCallback(callback, null, [{user:username, pwd:userPassword}]);
+ if(err) return handleCallback(callback, err, null)
+ handleCallback(callback, null, [{user:username, pwd:userPassword}]);
+ });
+ });
+ });
+
+ return;
+ }
+
+ if(err) return handleCallback(callback, err);
+ handleCallback(callback, err, r);
+ });
+};
+
+var _executeAuthRemoveUserCommand = function(self, username, options, callback) {
+ if(typeof options == 'function') callback = options, options = {};
+ // Get the error options
+ var commandOptions = {writeCommand:true};
+ if(options['dbName']) commandOptions.dbName = options['dbName'];
+
+ // Get additional values
+ var maxTimeMS = typeof options.maxTimeMS == 'number' ? options.maxTimeMS : null;
+
+ // Add maxTimeMS to options if set
+ if(maxTimeMS != null) commandOptions.maxTimeMS = maxTimeMS;
+
+ // Build the command to execute
+ var command = {
+ dropUser: username
+ }
+
+ // Apply write concern to command
+ command = writeConcern(command, self, options);
+
+ // Force write using primary
+ commandOptions.readPreference = CoreReadPreference.primary;
+
+ // Execute the command
+ self.command(command, commandOptions, function(err, result) {
+ if(err && !err.ok && err.code == undefined) return handleCallback(callback, {code: -5000});
+ if(err) return handleCallback(callback, err, null);
+ handleCallback(callback, null, result.ok ? true : false);
+ })
+}
+
+/**
+ * Remove a user from a database
+ * @method
+ * @param {string} username The username.
+ * @param {object} [options=null] Optional settings.
+ * @param {(number|string)} [options.w=null] The write concern.
+ * @param {number} [options.wtimeout=null] The write concern timeout.
+ * @param {boolean} [options.j=false] Specify a journal write concern.
+ * @param {Db~resultCallback} callback The command result callback
+ * @return {null}
+ */
+Db.prototype.removeUser = function(username, options, callback) {
+ // Unpack the parameters
+ var self = this;
+ var args = Array.prototype.slice.call(arguments, 1);
+ callback = args.pop();
+ options = args.length ? args.shift() || {} : {};
+
+ // Attempt to execute command
+ _executeAuthRemoveUserCommand(this, username, options, function(err, result) {
+ if(err && err.code == -5000) {
+ var finalOptions = writeConcern(shallowClone(options), self, options);
+ // If we have another db set
+ var db = options.dbName ? self.db(options.dbName) : self;
+
+ // Fetch a user collection
+ var collection = db.collection(Db.SYSTEM_USER_COLLECTION);
+
+ // Locate the user
+ collection.findOne({user: username}, {}, function(err, user) {
+ if(user == null) return handleCallback(callback, err, false);
+ collection.remove({user: username}, finalOptions, function(err, result) {
+ handleCallback(callback, err, true);
+ });
+ });
+
+ return;
+ }
+
+ if(err) return handleCallback(callback, err);
+ handleCallback(callback, err, result);
+ });
+};
+
+/**
+ * Authenticate a user against the server.
+ * @method
+ * @param {string} username The username.
+ * @param {string} [password] The password.
+ * @param {object} [options=null] Optional settings.
+ * @param {string} [options.authMechanism=MONGODB-CR] The authentication mechanism to use, GSSAPI, MONGODB-CR, MONGODB-X509, PLAIN
+ * @param {Db~resultCallback} callback The command result callback
+ * @return {null}
+ */
+Db.prototype.authenticate = function(username, password, options, callback) {
+ if(typeof options == 'function') callback = options, options = {};
+ var self = this;
+ // Set default mechanism
+ if(!options.authMechanism) {
+ options.authMechanism = 'DEFAULT';
+ } else if(options.authMechanism != 'GSSAPI'
+ && options.authMechanism != 'MONGODB-CR'
+ && options.authMechanism != 'MONGODB-X509'
+ && options.authMechanism != 'SCRAM-SHA-1'
+ && options.authMechanism != 'PLAIN') {
+ return handleCallback(callback, new MongoError("only GSSAPI, PLAIN, MONGODB-X509, SCRAM-SHA-1 or MONGODB-CR is supported by authMechanism"));
+ }
+
+ // the default db to authenticate against is 'this'
+ // if authententicate is called from a retry context, it may be another one, like admin
+ var authdb = options.authdb ? options.authdb : options.dbName;
+ authdb = options.authSource ? options.authSource : authdb;
+ authdb = authdb ? authdb : this.databaseName;
+
+ // Callback
+ var _callback = function(err, result) {
+ if(self.listeners('authenticated').length > 0) {
+ self.emit('authenticated', err, result);
+ }
+
+ // Return to caller
+ handleCallback(callback, err, result);
+ }
+
+ // authMechanism
+ var authMechanism = options.authMechanism || '';
+ authMechanism = authMechanism.toUpperCase();
+
+ // If classic auth delegate to auth command
+ if(authMechanism == 'MONGODB-CR') {
+ this.s.topology.auth('mongocr', authdb, username, password, function(err, result) {
+ if(err) return handleCallback(callback, err, false);
+ _callback(null, true);
+ });
+ } else if(authMechanism == 'PLAIN') {
+ this.s.topology.auth('plain', authdb, username, password, function(err, result) {
+ if(err) return handleCallback(callback, err, false);
+ _callback(null, true);
+ });
+ } else if(authMechanism == 'MONGODB-X509') {
+ this.s.topology.auth('x509', authdb, username, password, function(err, result) {
+ if(err) return handleCallback(callback, err, false);
+ _callback(null, true);
+ });
+ } else if(authMechanism == 'SCRAM-SHA-1') {
+ this.s.topology.auth('scram-sha-1', authdb, username, password, function(err, result) {
+ if(err) return handleCallback(callback, err, false);
+ _callback(null, true);
+ });
+ } else if(authMechanism == 'GSSAPI') {
+ if(process.platform == 'win32') {
+ this.s.topology.auth('sspi', authdb, username, password, options, function(err, result) {
+ if(err) return handleCallback(callback, err, false);
+ _callback(null, true);
+ });
+ } else {
+ this.s.topology.auth('gssapi', authdb, username, password, options, function(err, result) {
+ if(err) return handleCallback(callback, err, false);
+ _callback(null, true);
+ });
+ }
+ } else if(authMechanism == 'DEFAULT') {
+ this.s.topology.auth('default', authdb, username, password, function(err, result) {
+ if(err) return handleCallback(callback, err, false);
+ _callback(null, true);
+ });
+ } else {
+ handleCallback(callback, new MongoError(f("authentication mechanism %s not supported", options.authMechanism), false));
+ }
+};
+
+/**
+ * Logout user from server, fire off on all connections and remove all auth info
+ * @method
+ * @param {object} [options=null] Optional settings.
+ * @param {string} [options.dbName=null] Logout against different database than current.
+ * @param {Db~resultCallback} callback The command result callback
+ * @return {null}
+ */
+Db.prototype.logout = function(options, callback) {
+ var args = Array.prototype.slice.call(arguments, 0);
+ callback = args.pop();
+ options = args.length ? args.shift() || {} : {};
+
+ // logout command
+ var cmd = {'logout':1};
+
+ // Add onAll to login to ensure all connection are logged out
+ options.onAll = true;
+
+ // We authenticated against a different db use that
+ if(this.s.authSource) options.dbName = this.s.authSource;
+
+ // Execute the command
+ this.command(cmd, options, function(err, result) {
+ if(err) return handleCallback(callback, err, false);
+ handleCallback(callback, null, true)
+ });
+}
+
+// Figure out the read preference
+var getReadPreference = function(options, db) {
+ if(options.readPreference) return options;
+ if(db.readPreference) options.readPreference = db.readPreference;
+ return options;
+}
+
+/**
+ * Retrieves this collections index info.
+ * @method
+ * @param {string} name The name of the collection.
+ * @param {object} [options=null] Optional settings.
+ * @param {boolean} [options.full=false] Returns the full raw index information.
+ * @param {(ReadPreference|string)} [options.readPreference=null] The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).
+ * @param {Db~resultCallback} callback The command result callback
+ * @return {null}
+ */
+Db.prototype.indexInformation = function(name, options, callback) {
+ if(typeof callback === 'undefined') {
+ if(typeof options === 'undefined') {
+ callback = name;
+ name = null;
+ } else {
+ callback = options;
+ }
+ options = {};
+ }
+
+ // If we specified full information
+ var full = options['full'] == null ? false : options['full'];
+ var self = this;
+
+ // Process all the results from the index command and collection
+ var processResults = function(indexes) {
+ // Contains all the information
+ var info = {};
+ // Process all the indexes
+ for(var i = 0; i < indexes.length; i++) {
+ var index = indexes[i];
+ // Let's unpack the object
+ info[index.name] = [];
+ for(var name in index.key) {
+ info[index.name].push([name, index.key[name]]);
+ }
+ }
+
+ return info;
+ }
+
+ // Get the list of indexes of the specified collection
+ this.collection(name).listIndexes().toArray(function(err, indexes) {
+ if(err) return callback(toError(err));
+ if(!Array.isArray(indexes)) return handleCallback(callback, null, []);
+ if(full) return handleCallback(callback, null, indexes);
+ handleCallback(callback, null, processResults(indexes));
+ });
+};
+
+var createCreateIndexCommand = function(db, name, fieldOrSpec, options) {
+ var indexParameters = parseIndexOptions(fieldOrSpec);
+ var fieldHash = indexParameters.fieldHash;
+ var keys = indexParameters.keys;
+
+ // Generate the index name
+ var indexName = typeof options.name == 'string' ? options.name : indexParameters.name;
+ var selector = {
+ 'ns': db.databaseName + "." + name, 'key': fieldHash, 'name': indexName
+ }
+
+ // Ensure we have a correct finalUnique
+ var finalUnique = options == null || 'object' === typeof options ? false : options;
+ // Set up options
+ options = options == null || typeof options == 'boolean' ? {} : options;
+
+ // Add all the options
+ var keysToOmit = Object.keys(selector);
+ for(var optionName in options) {
+ if(keysToOmit.indexOf(optionName) == -1) {
+ selector[optionName] = options[optionName];
+ }
+ }
+
+ if(selector['unique'] == null) selector['unique'] = finalUnique;
+
+ // Remove any write concern operations
+ var removeKeys = ['w', 'wtimeout', 'j', 'fsync', 'readPreference'];
+ for(var i = 0; i < removeKeys.length; i++) {
+ delete selector[removeKeys[i]];
+ }
+
+ // Return the command creation selector
+ return selector;
+}
+
+var createIndexUsingCreateIndexes = function(self, name, fieldOrSpec, options, callback) {
+ // Build the index
+ var indexParameters = parseIndexOptions(fieldOrSpec);
+ // Generate the index name
+ var indexName = typeof options.name == 'string' ? options.name : indexParameters.name;
+ // Set up the index
+ var indexes = [{ name: indexName, key: indexParameters.fieldHash }];
+ // merge all the options
+ var keysToOmit = Object.keys(indexes[0]);
+ for(var optionName in options) {
+ if(keysToOmit.indexOf(optionName) == -1) {
+ indexes[0][optionName] = options[optionName];
+ }
+
+ // Remove any write concern operations
+ var removeKeys = ['w', 'wtimeout', 'j', 'fsync', 'readPreference'];
+ for(var i = 0; i < removeKeys.length; i++) {
+ delete indexes[0][removeKeys[i]];
+ }
+ }
+
+ // Create command
+ var cmd = {createIndexes: name, indexes: indexes};
+
+ // Apply write concern to command
+ cmd = writeConcern(cmd, self, options);
+
+ // Build the command
+ self.command(cmd, options, function(err, result) {
+ if(err) return handleCallback(callback, err, null);
+ if(result.ok == 0) return handleCallback(callback, toError(result), null);
+ // Return the indexName for backward compatibility
+ handleCallback(callback, null, indexName);
+ });
+}
+
+// Validate the database name
+var validateDatabaseName = function(databaseName) {
+ if(typeof databaseName !== 'string') throw new MongoError("database name must be a string");
+ if(databaseName.length === 0) throw new MongoError("database name cannot be the empty string");
+ if(databaseName == '$external') return;
+
+ var invalidChars = [" ", ".", "$", "/", "\\"];
+ for(var i = 0; i < invalidChars.length; i++) {
+ if(databaseName.indexOf(invalidChars[i]) != -1) throw new MongoError("database names cannot contain the character '" + invalidChars[i] + "'");
+ }
+}
+
+// Get write concern
+var writeConcern = function(target, db, options) {
+ if(options.w != null || options.j != null || options.fsync != null) {
+ var opts = {};
+ if(options.w) opts.w = options.w;
+ if(options.wtimeout) opts.wtimeout = options.wtimeout;
+ if(options.j) opts.j = options.j;
+ if(options.fsync) opts.fsync = options.fsync;
+ target.writeConcern = opts;
+ } else if(db.writeConcern.w != null || db.writeConcern.j != null || db.writeConcern.fsync != null) {
+ target.writeConcern = db.writeConcern;
+ }
+
+ return target
+}
+
+// Add listeners to topology
+var createListener = function(self, e, object) {
+ var listener = function(err) {
+ if(e != 'error') {
+ object.emit(e, err, self);
+ }
+ }
+ return listener;
+}
+
+/**
+ * Db close event
+ *
+ * @event Db#close
+ * @type {object}
+ */
+
+/**
+ * Db authenticated event
+ *
+ * @event Db#authenticated
+ * @type {object}
+ */
+
+/**
+ * Db reconnect event
+ *
+ * @event Db#reconnect
+ * @type {object}
+ */
+
+/**
+ * Db error event
+ *
+ * @event Db#error
+ * @type {MongoError}
+ */
+
+/**
+ * Db timeout event
+ *
+ * @event Db#timeout
+ * @type {object}
+ */
+
+/**
+ * Db parseError event
+ *
+ * @event Db#parseError
+ * @type {object}
+ */
+
+/**
+ * Db fullsetup event, emitted when all servers in the topology have been connected to.
+ *
+ * @event Db#fullsetup
+ * @type {Db}
+ */
+
+// Constants
+Db.SYSTEM_NAMESPACE_COLLECTION = "system.namespaces";
+Db.SYSTEM_INDEX_COLLECTION = "system.indexes";
+Db.SYSTEM_PROFILE_COLLECTION = "system.profile";
+Db.SYSTEM_USER_COLLECTION = "system.users";
+Db.SYSTEM_COMMAND_COLLECTION = "$cmd";
+Db.SYSTEM_JS_COLLECTION = "system.js";
+
+module.exports = Db;
diff --git a/server/node_modules/mongodb/lib/gridfs/chunk.js b/server/node_modules/mongodb/lib/gridfs/chunk.js
new file mode 100755
index 00000000..eb1beed2
--- /dev/null
+++ b/server/node_modules/mongodb/lib/gridfs/chunk.js
@@ -0,0 +1,236 @@
+"use strict";
+
+var Binary = require('mongodb-core').BSON.Binary,
+ ObjectID = require('mongodb-core').BSON.ObjectID;
+
+/**
+ * Class for representing a single chunk in GridFS.
+ *
+ * @class
+ *
+ * @param file {GridStore} The {@link GridStore} object holding this chunk.
+ * @param mongoObject {object} The mongo object representation of this chunk.
+ *
+ * @throws Error when the type of data field for {@link mongoObject} is not
+ * supported. Currently supported types for data field are instances of
+ * {@link String}, {@link Array}, {@link Binary} and {@link Binary}
+ * from the bson module
+ *
+ * @see Chunk#buildMongoObject
+ */
+var Chunk = function(file, mongoObject, writeConcern) {
+ if(!(this instanceof Chunk)) return new Chunk(file, mongoObject);
+
+ this.file = file;
+ var self = this;
+ var mongoObjectFinal = mongoObject == null ? {} : mongoObject;
+ this.writeConcern = writeConcern || {w:1};
+ this.objectId = mongoObjectFinal._id == null ? new ObjectID() : mongoObjectFinal._id;
+ this.chunkNumber = mongoObjectFinal.n == null ? 0 : mongoObjectFinal.n;
+ this.data = new Binary();
+
+ if(mongoObjectFinal.data == null) {
+ } else if(typeof mongoObjectFinal.data == "string") {
+ var buffer = new Buffer(mongoObjectFinal.data.length);
+ buffer.write(mongoObjectFinal.data, 'binary', 0);
+ this.data = new Binary(buffer);
+ } else if(Array.isArray(mongoObjectFinal.data)) {
+ var buffer = new Buffer(mongoObjectFinal.data.length);
+ buffer.write(mongoObjectFinal.data.join(''), 'binary', 0);
+ this.data = new Binary(buffer);
+ } else if(mongoObjectFinal.data._bsontype === 'Binary') {
+ this.data = mongoObjectFinal.data;
+ } else if(Buffer.isBuffer(mongoObjectFinal.data)) {
+ } else {
+ throw Error("Illegal chunk format");
+ }
+
+ // Update position
+ this.internalPosition = 0;
+};
+
+/**
+ * Writes a data to this object and advance the read/write head.
+ *
+ * @param data {string} the data to write
+ * @param callback {function(*, GridStore)} This will be called after executing
+ * this method. The first parameter will contain null and the second one
+ * will contain a reference to this object.
+ */
+Chunk.prototype.write = function(data, callback) {
+ this.data.write(data, this.internalPosition);
+ this.internalPosition = this.data.length();
+ if(callback != null) return callback(null, this);
+ return this;
+};
+
+/**
+ * Reads data and advances the read/write head.
+ *
+ * @param length {number} The length of data to read.
+ *
+ * @return {string} The data read if the given length will not exceed the end of
+ * the chunk. Returns an empty String otherwise.
+ */
+Chunk.prototype.read = function(length) {
+ // Default to full read if no index defined
+ length = length == null || length == 0 ? this.length() : length;
+
+ if(this.length() - this.internalPosition + 1 >= length) {
+ var data = this.data.read(this.internalPosition, length);
+ this.internalPosition = this.internalPosition + length;
+ return data;
+ } else {
+ return '';
+ }
+};
+
+Chunk.prototype.readSlice = function(length) {
+ if ((this.length() - this.internalPosition) >= length) {
+ var data = null;
+ if (this.data.buffer != null) { //Pure BSON
+ data = this.data.buffer.slice(this.internalPosition, this.internalPosition + length);
+ } else { //Native BSON
+ data = new Buffer(length);
+ length = this.data.readInto(data, this.internalPosition);
+ }
+ this.internalPosition = this.internalPosition + length;
+ return data;
+ } else {
+ return null;
+ }
+};
+
+/**
+ * Checks if the read/write head is at the end.
+ *
+ * @return {boolean} Whether the read/write head has reached the end of this
+ * chunk.
+ */
+Chunk.prototype.eof = function() {
+ return this.internalPosition == this.length() ? true : false;
+};
+
+/**
+ * Reads one character from the data of this chunk and advances the read/write
+ * head.
+ *
+ * @return {string} a single character data read if the the read/write head is
+ * not at the end of the chunk. Returns an empty String otherwise.
+ */
+Chunk.prototype.getc = function() {
+ return this.read(1);
+};
+
+/**
+ * Clears the contents of the data in this chunk and resets the read/write head
+ * to the initial position.
+ */
+Chunk.prototype.rewind = function() {
+ this.internalPosition = 0;
+ this.data = new Binary();
+};
+
+/**
+ * Saves this chunk to the database. Also overwrites existing entries having the
+ * same id as this chunk.
+ *
+ * @param callback {function(*, GridStore)} This will be called after executing
+ * this method. The first parameter will contain null and the second one
+ * will contain a reference to this object.
+ */
+Chunk.prototype.save = function(options, callback) {
+ var self = this;
+ if(typeof options == 'function') {
+ callback = options;
+ options = {};
+ }
+
+ self.file.chunkCollection(function(err, collection) {
+ if(err) return callback(err);
+
+ // Merge the options
+ var writeOptions = {};
+ for(var name in options) writeOptions[name] = options[name];
+ for(var name in self.writeConcern) writeOptions[name] = self.writeConcern[name];
+
+ // collection.remove({'_id':self.objectId}, self.writeConcern, function(err, result) {
+ collection.remove({'_id':self.objectId}, writeOptions, function(err, result) {
+ if(err) return callback(err);
+
+ if(self.data.length() > 0) {
+ self.buildMongoObject(function(mongoObject) {
+ var options = {forceServerObjectId:true};
+ for(var name in self.writeConcern) {
+ options[name] = self.writeConcern[name];
+ }
+
+ collection.insert(mongoObject, writeOptions, function(err, collection) {
+ callback(err, self);
+ });
+ });
+ } else {
+ callback(null, self);
+ }
+ });
+ });
+};
+
+/**
+ * Creates a mongoDB object representation of this chunk.
+ *
+ * @param callback {function(Object)} This will be called after executing this
+ * method. The object will be passed to the first parameter and will have
+ * the structure:
+ *
+ *
+ * {
+ * '_id' : , // {number} id for this chunk
+ * 'files_id' : , // {number} foreign key to the file collection
+ * 'n' : , // {number} chunk number
+ * 'data' : , // {bson#Binary} the chunk data itself
+ * }
+ *
+ *
+ * @see MongoDB GridFS Chunk Object Structure
+ */
+Chunk.prototype.buildMongoObject = function(callback) {
+ var mongoObject = {
+ 'files_id': this.file.fileId,
+ 'n': this.chunkNumber,
+ 'data': this.data};
+ // If we are saving using a specific ObjectId
+ if(this.objectId != null) mongoObject._id = this.objectId;
+
+ callback(mongoObject);
+};
+
+/**
+ * @return {number} the length of the data
+ */
+Chunk.prototype.length = function() {
+ return this.data.length();
+};
+
+/**
+ * The position of the read/write head
+ * @name position
+ * @lends Chunk#
+ * @field
+ */
+Object.defineProperty(Chunk.prototype, "position", { enumerable: true
+ , get: function () {
+ return this.internalPosition;
+ }
+ , set: function(value) {
+ this.internalPosition = value;
+ }
+});
+
+/**
+ * The default chunk size
+ * @constant
+ */
+Chunk.DEFAULT_CHUNK_SIZE = 1024 * 255;
+
+module.exports = Chunk;
\ No newline at end of file
diff --git a/server/node_modules/mongodb/lib/gridfs/grid_store.js b/server/node_modules/mongodb/lib/gridfs/grid_store.js
new file mode 100755
index 00000000..612e4bf1
--- /dev/null
+++ b/server/node_modules/mongodb/lib/gridfs/grid_store.js
@@ -0,0 +1,1582 @@
+"use strict";
+
+/**
+ * @fileOverview GridFS is a tool for MongoDB to store files to the database.
+ * Because of the restrictions of the object size the database can hold, a
+ * facility to split a file into several chunks is needed. The {@link GridStore}
+ * class offers a simplified api to interact with files while managing the
+ * chunks of split files behind the scenes. More information about GridFS can be
+ * found here.
+ *
+ * @example
+ * var MongoClient = require('mongodb').MongoClient,
+ * GridStore = require('mongodb').GridStore,
+ * ObjectID = require('mongodb').ObjectID,
+ * test = require('assert');
+ *
+ * // Connection url
+ * var url = 'mongodb://localhost:27017/test';
+ * // Connect using MongoClient
+ * MongoClient.connect(url, function(err, db) {
+ * var gridStore = new GridStore(db, null, "w");
+ * gridStore.open(function(err, gridStore) {
+ * gridStore.write("hello world!", function(err, gridStore) {
+ * gridStore.close(function(err, result) {
+ *
+ * // Let's read the file using object Id
+ * GridStore.read(db, result._id, function(err, data) {
+ * test.equal('hello world!', data);
+ * db.close();
+ * test.done();
+ * });
+ * });
+ * });
+ * });
+ * });
+ */
+var Chunk = require('./chunk'),
+ ObjectID = require('mongodb-core').BSON.ObjectID,
+ Buffer = require('buffer').Buffer,
+ fs = require('fs'),
+ timers = require('timers'),
+ f = require('util').format,
+ util = require('util'),
+ MongoError = require('mongodb-core').MongoError,
+ inherits = util.inherits,
+ Duplex = require('stream').Duplex || require('readable-stream').Duplex;
+
+var REFERENCE_BY_FILENAME = 0,
+ REFERENCE_BY_ID = 1;
+
+/**
+ * Namespace provided by the mongodb-core and node.js
+ * @external Duplex
+ */
+
+/**
+ * Create a new GridStore instance
+ *
+ * Modes
+ * - **"r"** - read only. This is the default mode.
+ * - **"w"** - write in truncate mode. Existing data will be overwriten.
+ *
+ * @class
+ * @param {Db} db A database instance to interact with.
+ * @param {object} [id] optional unique id for this file
+ * @param {string} [filename] optional filename for this file, no unique constrain on the field
+ * @param {string} mode set the mode for this file.
+ * @param {object} [options=null] Optional settings.
+ * @param {(number|string)} [options.w=null] The write concern.
+ * @param {number} [options.wtimeout=null] The write concern timeout.
+ * @param {boolean} [options.j=false] Specify a journal write concern.
+ * @param {boolean} [options.fsync=false] Specify a file sync write concern.
+ * @param {string} [options.root=null] Root collection to use. Defaults to **{GridStore.DEFAULT_ROOT_COLLECTION}**.
+ * @param {string} [options.content_type=null] MIME type of the file. Defaults to **{GridStore.DEFAULT_CONTENT_TYPE}**.
+ * @param {number} [options.chunk_size=261120] Size for the chunk. Defaults to **{Chunk.DEFAULT_CHUNK_SIZE}**.
+ * @param {object} [options.metadata=null] Arbitrary data the user wants to store.
+ * @param {(ReadPreference|string)} [options.readPreference=null] The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).
+ * @property {number} chunkSize Get the gridstore chunk size.
+ * @property {number} md5 The md5 checksum for this file.
+ * @property {number} chunkNumber The current chunk number the gridstore has materialized into memory
+ * @return {GridStore} a GridStore instance.
+ */
+var GridStore = function GridStore(db, id, filename, mode, options) {
+ if(!(this instanceof GridStore)) return new GridStore(db, id, filename, mode, options);
+ var self = this;
+ this.db = db;
+
+ // Handle options
+ if(typeof options === 'undefined') options = {};
+ // Handle mode
+ if(typeof mode === 'undefined') {
+ mode = filename;
+ filename = undefined;
+ } else if(typeof mode == 'object') {
+ options = mode;
+ mode = filename;
+ filename = undefined;
+ }
+
+ if(id instanceof ObjectID) {
+ this.referenceBy = REFERENCE_BY_ID;
+ this.fileId = id;
+ this.filename = filename;
+ } else if(typeof filename == 'undefined') {
+ this.referenceBy = REFERENCE_BY_FILENAME;
+ this.filename = id;
+ if (mode.indexOf('w') != null) {
+ this.fileId = new ObjectID();
+ }
+ } else {
+ this.referenceBy = REFERENCE_BY_ID;
+ this.fileId = id;
+ this.filename = filename;
+ }
+
+ // Set up the rest
+ this.mode = mode == null ? "r" : mode;
+ this.options = options || {};
+
+ // Opened
+ this.isOpen = false;
+
+ // Set the root if overridden
+ this.root = this.options['root'] == null ? GridStore.DEFAULT_ROOT_COLLECTION : this.options['root'];
+ this.position = 0;
+ this.readPreference = this.options.readPreference || 'primary';
+ this.writeConcern = _getWriteConcern(db, this.options);
+ // Set default chunk size
+ this.internalChunkSize = this.options['chunkSize'] == null ? Chunk.DEFAULT_CHUNK_SIZE : this.options['chunkSize'];
+
+ Object.defineProperty(this, "chunkSize", { enumerable: true
+ , get: function () {
+ return this.internalChunkSize;
+ }
+ , set: function(value) {
+ if(!(this.mode[0] == "w" && this.position == 0 && this.uploadDate == null)) {
+ this.internalChunkSize = this.internalChunkSize;
+ } else {
+ this.internalChunkSize = value;
+ }
+ }
+ });
+
+ Object.defineProperty(this, "md5", { enumerable: true
+ , get: function () {
+ return this.internalMd5;
+ }
+ });
+
+ Object.defineProperty(this, "chunkNumber", { enumerable: true
+ , get: function () {
+ return this.currentChunk && this.currentChunk.chunkNumber ? this.currentChunk.chunkNumber : null;
+ }
+ });
+}
+
+/**
+ * The callback format for the Gridstore.open method
+ * @callback Gridstore~openCallback
+ * @param {MongoError} error An error instance representing the error during the execution.
+ * @param {GridStore} gridStore The GridStore instance if the open method was successful.
+ */
+
+/**
+ * Opens the file from the database and initialize this object. Also creates a
+ * new one if file does not exist.
+ *
+ * @method
+ * @param {Gridstore~openCallback} callback this will be called after executing this method
+ * @return {null}
+ */
+GridStore.prototype.open = function(callback) {
+ if( this.mode != "w" && this.mode != "w+" && this.mode != "r"){
+ callback(new MongoError("Illegal mode " + this.mode), null);
+ return;
+ }
+
+ var self = this;
+
+ // Get the write concern
+ var writeConcern = _getWriteConcern(this.db, this.options);
+
+ // If we are writing we need to ensure we have the right indexes for md5's
+ if((self.mode == "w" || self.mode == "w+")) {
+ // Get files collection
+ var collection = self.collection();
+ // Put index on filename
+ collection.ensureIndex([['filename', 1]], writeConcern, function(err, index) {
+ // Get chunk collection
+ var chunkCollection = self.chunkCollection();
+ // Ensure index on chunk collection
+ chunkCollection.ensureIndex([['files_id', 1], ['n', 1]], writeConcern, function(err, index) {
+ // Open the connection
+ _open(self, writeConcern, function(err, r) {
+ if(err) return callback(err);
+ self.isOpen = true;
+ callback(err, r);
+ });
+ });
+ });
+ } else {
+ // Open the gridstore
+ _open(self, writeConcern, function(err, r) {
+ if(err) return callback(err);
+ self.isOpen = true;
+ callback(err, r);
+ });
+ }
+};
+
+/**
+ * Verify if the file is at EOF.
+ *
+ * @method
+ * @return {boolean} true if the read/write head is at the end of this file.
+ */
+GridStore.prototype.eof = function() {
+ return this.position == this.length ? true : false;
+}
+
+/**
+ * The callback result format.
+ * @callback Gridstore~resultCallback
+ * @param {MongoError} error An error instance representing the error during the execution.
+ * @param {object} result The result from the callback.
+ */
+
+/**
+ * Retrieves a single character from this file.
+ *
+ * @method
+ * @param {Gridstore~resultCallback} callback this gets called after this method is executed. Passes null to the first parameter and the character read to the second or null to the second if the read/write head is at the end of the file.
+ * @return {null}
+ */
+GridStore.prototype.getc = function(callback) {
+ var self = this;
+
+ if(self.eof()) {
+ callback(null, null);
+ } else if(self.currentChunk.eof()) {
+ nthChunk(self, self.currentChunk.chunkNumber + 1, function(err, chunk) {
+ self.currentChunk = chunk;
+ self.position = self.position + 1;
+ callback(err, self.currentChunk.getc());
+ });
+ } else {
+ self.position = self.position + 1;
+ callback(null, self.currentChunk.getc());
+ }
+}
+
+/**
+ * Writes a string to the file with a newline character appended at the end if
+ * the given string does not have one.
+ *
+ * @method
+ * @param {string} string the string to write.
+ * @param {Gridstore~resultCallback} callback this will be called after executing this method. The first parameter will contain null and the second one will contain a reference to this object.
+ * @return {null}
+ */
+GridStore.prototype.puts = function(string, callback) {
+ var finalString = string.match(/\n$/) == null ? string + "\n" : string;
+ this.write(finalString, callback);
+}
+
+/**
+ * Return a modified Readable stream including a possible transform method.
+ *
+ * @method
+ * @return {GridStoreStream}
+ */
+GridStore.prototype.stream = function() {
+ return new GridStoreStream(this);
+}
+
+/**
+ * Writes some data. This method will work properly only if initialized with mode "w" or "w+".
+ *
+ * @method
+ * @param {(string|Buffer)} data the data to write.
+ * @param {boolean} [close] closes this file after writing if set to true.
+ * @param {Gridstore~resultCallback} callback this will be called after executing this method. The first parameter will contain null and the second one will contain a reference to this object.
+ * @return {null}
+ */
+GridStore.prototype.write = function write(data, close, callback) {
+ return _writeNormal(this, data, close, callback);
+}
+
+/**
+ * Handles the destroy part of a stream
+ *
+ * @method
+ * @result {null}
+ */
+GridStore.prototype.destroy = function destroy() {
+ // close and do not emit any more events. queued data is not sent.
+ if(!this.writable) return;
+ this.readable = false;
+ if(this.writable) {
+ this.writable = false;
+ this._q.length = 0;
+ this.emit('close');
+ }
+}
+
+/**
+ * Stores a file from the file system to the GridFS database.
+ *
+ * @method
+ * @param {(string|Buffer|FileHandle)} file the file to store.
+ * @param {Gridstore~resultCallback} callback this will be called after executing this method. The first parameter will contain null and the second one will contain a reference to this object.
+ * @return {null}
+ */
+GridStore.prototype.writeFile = function (file, callback) {
+ var self = this;
+ if (typeof file === 'string') {
+ fs.open(file, 'r', function (err, fd) {
+ if(err) return callback(err);
+ self.writeFile(fd, callback);
+ });
+ return;
+ }
+
+ self.open(function (err, self) {
+ if(err) return callback(err, self);
+
+ fs.fstat(file, function (err, stats) {
+ if(err) return callback(err, self);
+
+ var offset = 0;
+ var index = 0;
+ var numberOfChunksLeft = Math.min(stats.size / self.chunkSize);
+
+ // Write a chunk
+ var writeChunk = function() {
+ fs.read(file, self.chunkSize, offset, 'binary', function(err, data, bytesRead) {
+ if(err) return callback(err, self);
+
+ offset = offset + bytesRead;
+
+ // Create a new chunk for the data
+ var chunk = new Chunk(self, {n:index++}, self.writeConcern);
+ chunk.write(data, function(err, chunk) {
+ if(err) return callback(err, self);
+
+ chunk.save({}, function(err, result) {
+ if(err) return callback(err, self);
+
+ self.position = self.position + data.length;
+
+ // Point to current chunk
+ self.currentChunk = chunk;
+
+ if(offset >= stats.size) {
+ fs.close(file);
+ self.close(function(err, result) {
+ if(err) return callback(err, self);
+ return callback(null, self);
+ });
+ } else {
+ return process.nextTick(writeChunk);
+ }
+ });
+ });
+ });
+ }
+
+ // Process the first write
+ process.nextTick(writeChunk);
+ });
+ });
+};
+
+/**
+ * Saves this file to the database. This will overwrite the old entry if it
+ * already exists. This will work properly only if mode was initialized to
+ * "w" or "w+".
+ *
+ * @method
+ * @param {Gridstore~resultCallback} callback this will be called after executing this method. The first parameter will contain null and the second one will contain a reference to this object.
+ * @return {null}
+ */
+GridStore.prototype.close = function(callback) {
+ var self = this;
+
+ if(self.mode[0] == "w") {
+ // Set up options
+ var options = self.writeConcern;
+
+ if(self.currentChunk != null && self.currentChunk.position > 0) {
+ self.currentChunk.save({}, function(err, chunk) {
+ if(err && typeof callback == 'function') return callback(err);
+
+ self.collection(function(err, files) {
+ if(err && typeof callback == 'function') return callback(err);
+
+ // Build the mongo object
+ if(self.uploadDate != null) {
+ files.remove({'_id':self.fileId}, self.writeConcern, function(err, collection) {
+ if(err && typeof callback == 'function') return callback(err);
+
+ buildMongoObject(self, function(err, mongoObject) {
+ if(err) {
+ if(typeof callback == 'function') return callback(err); else throw err;
+ }
+
+ files.save(mongoObject, options, function(err) {
+ if(typeof callback == 'function')
+ callback(err, mongoObject);
+ });
+ });
+ });
+ } else {
+ self.uploadDate = new Date();
+ buildMongoObject(self, function(err, mongoObject) {
+ if(err) {
+ if(typeof callback == 'function') return callback(err); else throw err;
+ }
+
+ files.save(mongoObject, options, function(err) {
+ if(typeof callback == 'function')
+ callback(err, mongoObject);
+ });
+ });
+ }
+ });
+ });
+ } else {
+ self.collection(function(err, files) {
+ if(err && typeof callback == 'function') return callback(err);
+
+ self.uploadDate = new Date();
+ buildMongoObject(self, function(err, mongoObject) {
+ if(err) {
+ if(typeof callback == 'function') return callback(err); else throw err;
+ }
+
+ files.save(mongoObject, options, function(err) {
+ if(typeof callback == 'function')
+ callback(err, mongoObject);
+ });
+ });
+ });
+ }
+ } else if(self.mode[0] == "r") {
+ if(typeof callback == 'function')
+ callback(null, null);
+ } else {
+ if(typeof callback == 'function')
+ callback(new MongoError(f("Illegal mode %s", self.mode), null));
+ }
+};
+
+/**
+ * The collection callback format.
+ * @callback Gridstore~collectionCallback
+ * @param {MongoError} error An error instance representing the error during the execution.
+ * @param {Collection} collection The collection from the command execution.
+ */
+
+/**
+ * Retrieve this file's chunks collection.
+ *
+ * @method
+ * @param {Gridstore~collectionCallback} callback the command callback.
+ * @return {Collection}
+ */
+GridStore.prototype.chunkCollection = function(callback) {
+ if(typeof callback == 'function')
+ return this.db.collection((this.root + ".chunks"), callback);
+ return this.db.collection((this.root + ".chunks"));
+};
+
+/**
+ * Deletes all the chunks of this file in the database.
+ *
+ * @method
+ * @param {Gridstore~resultCallback} callback the command callback.
+ * @return {null}
+ */
+GridStore.prototype.unlink = function(callback) {
+ var self = this;
+ deleteChunks(this, function(err) {
+ if(err!==null) {
+ err.message = "at deleteChunks: " + err.message;
+ return callback(err);
+ }
+
+ self.collection(function(err, collection) {
+ if(err!==null) {
+ err.message = "at collection: " + err.message;
+ return callback(err);
+ }
+
+ collection.remove({'_id':self.fileId}, self.writeConcern, function(err) {
+ callback(err, self);
+ });
+ });
+ });
+};
+
+/**
+ * Retrieves the file collection associated with this object.
+ *
+ * @method
+ * @param {Gridstore~collectionCallback} callback the command callback.
+ * @return {Collection}
+ */
+GridStore.prototype.collection = function(callback) {
+ if(typeof callback == 'function')
+ this.db.collection(this.root + ".files", callback);
+ return this.db.collection(this.root + ".files");
+};
+
+/**
+ * The readlines callback format.
+ * @callback Gridstore~readlinesCallback
+ * @param {MongoError} error An error instance representing the error during the execution.
+ * @param {string[]} strings The array of strings returned.
+ */
+
+/**
+ * Read the entire file as a list of strings splitting by the provided separator.
+ *
+ * @method
+ * @param {string} [separator] The character to be recognized as the newline separator.
+ * @param {Gridstore~readlinesCallback} callback the command callback.
+ * @return {null}
+ */
+GridStore.prototype.readlines = function(separator, callback) {
+ var args = Array.prototype.slice.call(arguments, 0);
+ callback = args.pop();
+ separator = args.length ? args.shift() : "\n";
+
+ this.read(function(err, data) {
+ if(err) return callback(err);
+
+ var items = data.toString().split(separator);
+ items = items.length > 0 ? items.splice(0, items.length - 1) : [];
+ for(var i = 0; i < items.length; i++) {
+ items[i] = items[i] + separator;
+ }
+
+ callback(null, items);
+ });
+};
+
+/**
+ * Deletes all the chunks of this file in the database if mode was set to "w" or
+ * "w+" and resets the read/write head to the initial position.
+ *
+ * @method
+ * @param {Gridstore~resultCallback} callback this will be called after executing this method. The first parameter will contain null and the second one will contain a reference to this object.
+ * @return {null}
+ */
+GridStore.prototype.rewind = function(callback) {
+ var self = this;
+
+ if(this.currentChunk.chunkNumber != 0) {
+ if(this.mode[0] == "w") {
+ deleteChunks(self, function(err, gridStore) {
+ if(err) return callback(err);
+ self.currentChunk = new Chunk(self, {'n': 0}, self.writeConcern);
+ self.position = 0;
+ callback(null, self);
+ });
+ } else {
+ self.currentChunk(0, function(err, chunk) {
+ if(err) return callback(err);
+ self.currentChunk = chunk;
+ self.currentChunk.rewind();
+ self.position = 0;
+ callback(null, self);
+ });
+ }
+ } else {
+ self.currentChunk.rewind();
+ self.position = 0;
+ callback(null, self);
+ }
+};
+
+/**
+ * The read callback format.
+ * @callback Gridstore~readCallback
+ * @param {MongoError} error An error instance representing the error during the execution.
+ * @param {Buffer} data The data read from the GridStore object
+ */
+
+/**
+ * Retrieves the contents of this file and advances the read/write head. Works with Buffers only.
+ *
+ * There are 3 signatures for this method:
+ *
+ * (callback)
+ * (length, callback)
+ * (length, buffer, callback)
+ *
+ * @method
+ * @param {number} [length] the number of characters to read. Reads all the characters from the read/write head to the EOF if not specified.
+ * @param {(string|Buffer)} [buffer] a string to hold temporary data. This is used for storing the string data read so far when recursively calling this method.
+ * @param {Gridstore~readCallback} callback the command callback.
+ * @return {null}
+ */
+GridStore.prototype.read = function(length, buffer, callback) {
+ var self = this;
+
+ var args = Array.prototype.slice.call(arguments, 0);
+ callback = args.pop();
+ length = args.length ? args.shift() : null;
+ buffer = args.length ? args.shift() : null;
+
+ // The data is a c-terminated string and thus the length - 1
+ var finalLength = length == null ? self.length - self.position : length;
+ var finalBuffer = buffer == null ? new Buffer(finalLength) : buffer;
+ // Add a index to buffer to keep track of writing position or apply current index
+ finalBuffer._index = buffer != null && buffer._index != null ? buffer._index : 0;
+
+ if((self.currentChunk.length() - self.currentChunk.position + finalBuffer._index) >= finalLength) {
+ var slice = self.currentChunk.readSlice(finalLength - finalBuffer._index);
+ // Copy content to final buffer
+ slice.copy(finalBuffer, finalBuffer._index);
+ // Update internal position
+ self.position = self.position + finalBuffer.length;
+ // Check if we don't have a file at all
+ if(finalLength == 0 && finalBuffer.length == 0) return callback(new MongoError("File does not exist"), null);
+ // Else return data
+ return callback(null, finalBuffer);
+ }
+
+ // Read the next chunk
+ var slice = self.currentChunk.readSlice(self.currentChunk.length() - self.currentChunk.position);
+ // Copy content to final buffer
+ slice.copy(finalBuffer, finalBuffer._index);
+ // Update index position
+ finalBuffer._index += slice.length;
+
+ // Load next chunk and read more
+ nthChunk(self, self.currentChunk.chunkNumber + 1, function(err, chunk) {
+ if(err) return callback(err);
+
+ if(chunk.length() > 0) {
+ self.currentChunk = chunk;
+ self.read(length, finalBuffer, callback);
+ } else {
+ if(finalBuffer._index > 0) {
+ callback(null, finalBuffer)
+ } else {
+ callback(new MongoError("no chunks found for file, possibly corrupt"), null);
+ }
+ }
+ });
+}
+
+/**
+ * The tell callback format.
+ * @callback Gridstore~tellCallback
+ * @param {MongoError} error An error instance representing the error during the execution.
+ * @param {number} position The current read position in the GridStore.
+ */
+
+/**
+ * Retrieves the position of the read/write head of this file.
+ *
+ * @method
+ * @param {number} [length] the number of characters to read. Reads all the characters from the read/write head to the EOF if not specified.
+ * @param {(string|Buffer)} [buffer] a string to hold temporary data. This is used for storing the string data read so far when recursively calling this method.
+ * @param {Gridstore~tellCallback} callback the command callback.
+ * @return {null}
+ */
+GridStore.prototype.tell = function(callback) {
+ callback(null, this.position);
+};
+
+/**
+ * The tell callback format.
+ * @callback Gridstore~gridStoreCallback
+ * @param {MongoError} error An error instance representing the error during the execution.
+ * @param {GridStore} gridStore The gridStore.
+ */
+
+/**
+ * Moves the read/write head to a new location.
+ *
+ * There are 3 signatures for this method
+ *
+ * Seek Location Modes
+ * - **GridStore.IO_SEEK_SET**, **(default)** set the position from the start of the file.
+ * - **GridStore.IO_SEEK_CUR**, set the position from the current position in the file.
+ * - **GridStore.IO_SEEK_END**, set the position from the end of the file.
+ *
+ * @method
+ * @param {number} [position] the position to seek to
+ * @param {number} [seekLocation] seek mode. Use one of the Seek Location modes.
+ * @param {Gridstore~gridStoreCallback} callback the command callback.
+ * @return {null}
+ */
+GridStore.prototype.seek = function(position, seekLocation, callback) {
+ var self = this;
+
+ var args = Array.prototype.slice.call(arguments, 1);
+ callback = args.pop();
+ seekLocation = args.length ? args.shift() : null;
+
+ // Seek only supports read mode
+ if(self.mode != 'r') {
+ return callback(new MongoError("seek is only supported for mode r"))
+ }
+
+ var seekLocationFinal = seekLocation == null ? GridStore.IO_SEEK_SET : seekLocation;
+ var finalPosition = position;
+ var targetPosition = 0;
+
+ // Calculate the position
+ if(seekLocationFinal == GridStore.IO_SEEK_CUR) {
+ targetPosition = self.position + finalPosition;
+ } else if(seekLocationFinal == GridStore.IO_SEEK_END) {
+ targetPosition = self.length + finalPosition;
+ } else {
+ targetPosition = finalPosition;
+ }
+
+ // Get the chunk
+ var newChunkNumber = Math.floor(targetPosition/self.chunkSize);
+ if(newChunkNumber != self.currentChunk.chunkNumber) {
+ var seekChunk = function() {
+ nthChunk(self, newChunkNumber, function(err, chunk) {
+ self.currentChunk = chunk;
+ self.position = targetPosition;
+ self.currentChunk.position = (self.position % self.chunkSize);
+ callback(err, self);
+ });
+ };
+
+ seekChunk();
+ } else {
+ self.position = targetPosition;
+ self.currentChunk.position = (self.position % self.chunkSize);
+ callback(null, self);
+ }
+}
+
+/**
+ * @ignore
+ */
+var _open = function(self, options, callback) {
+ var collection = self.collection();
+ // Create the query
+ var query = self.referenceBy == REFERENCE_BY_ID ? {_id:self.fileId} : {filename:self.filename};
+ query = null == self.fileId && self.filename == null ? null : query;
+ options.readPreference = self.readPreference;
+
+ // Fetch the chunks
+ if(query != null) {
+ collection.findOne(query, options, function(err, doc) {
+ if(err) return error(err);
+
+ // Check if the collection for the files exists otherwise prepare the new one
+ if(doc != null) {
+ self.fileId = doc._id;
+ // Prefer a new filename over the existing one if this is a write
+ self.filename = ((self.mode == 'r') || (self.filename == undefined)) ? doc.filename : self.filename;
+ self.contentType = doc.contentType;
+ self.internalChunkSize = doc.chunkSize;
+ self.uploadDate = doc.uploadDate;
+ self.aliases = doc.aliases;
+ self.length = doc.length;
+ self.metadata = doc.metadata;
+ self.internalMd5 = doc.md5;
+ } else if (self.mode != 'r') {
+ self.fileId = self.fileId == null ? new ObjectID() : self.fileId;
+ self.contentType = GridStore.DEFAULT_CONTENT_TYPE;
+ self.internalChunkSize = self.internalChunkSize == null ? Chunk.DEFAULT_CHUNK_SIZE : self.internalChunkSize;
+ self.length = 0;
+ } else {
+ self.length = 0;
+ var txtId = self.fileId instanceof ObjectID ? self.fileId.toHexString() : self.fileId;
+ return error(new MongoError(f("file with id %s not opened for writing", (self.referenceBy == REFERENCE_BY_ID ? txtId : self.filename))), self);
+ }
+
+ // Process the mode of the object
+ if(self.mode == "r") {
+ nthChunk(self, 0, options, function(err, chunk) {
+ if(err) return error(err);
+ self.currentChunk = chunk;
+ self.position = 0;
+ callback(null, self);
+ });
+ } else if(self.mode == "w") {
+ // Delete any existing chunks
+ deleteChunks(self, options, function(err, result) {
+ if(err) return error(err);
+ self.currentChunk = new Chunk(self, {'n':0}, self.writeConcern);
+ self.contentType = self.options['content_type'] == null ? self.contentType : self.options['content_type'];
+ self.internalChunkSize = self.options['chunk_size'] == null ? self.internalChunkSize : self.options['chunk_size'];
+ self.metadata = self.options['metadata'] == null ? self.metadata : self.options['metadata'];
+ self.aliases = self.options['aliases'] == null ? self.aliases : self.options['aliases'];
+ self.position = 0;
+ callback(null, self);
+ });
+ } else if(self.mode == "w+") {
+ nthChunk(self, lastChunkNumber(self), options, function(err, chunk) {
+ if(err) return error(err);
+ // Set the current chunk
+ self.currentChunk = chunk == null ? new Chunk(self, {'n':0}, self.writeConcern) : chunk;
+ self.currentChunk.position = self.currentChunk.data.length();
+ self.metadata = self.options['metadata'] == null ? self.metadata : self.options['metadata'];
+ self.aliases = self.options['aliases'] == null ? self.aliases : self.options['aliases'];
+ self.position = self.length;
+ callback(null, self);
+ });
+ }
+ });
+ } else {
+ // Write only mode
+ self.fileId = null == self.fileId ? new ObjectID() : self.fileId;
+ self.contentType = GridStore.DEFAULT_CONTENT_TYPE;
+ self.internalChunkSize = self.internalChunkSize == null ? Chunk.DEFAULT_CHUNK_SIZE : self.internalChunkSize;
+ self.length = 0;
+
+ var collection2 = self.chunkCollection();
+ // No file exists set up write mode
+ if(self.mode == "w") {
+ // Delete any existing chunks
+ deleteChunks(self, options, function(err, result) {
+ if(err) return error(err);
+ self.currentChunk = new Chunk(self, {'n':0}, self.writeConcern);
+ self.contentType = self.options['content_type'] == null ? self.contentType : self.options['content_type'];
+ self.internalChunkSize = self.options['chunk_size'] == null ? self.internalChunkSize : self.options['chunk_size'];
+ self.metadata = self.options['metadata'] == null ? self.metadata : self.options['metadata'];
+ self.aliases = self.options['aliases'] == null ? self.aliases : self.options['aliases'];
+ self.position = 0;
+ callback(null, self);
+ });
+ } else if(self.mode == "w+") {
+ nthChunk(self, lastChunkNumber(self), options, function(err, chunk) {
+ if(err) return error(err);
+ // Set the current chunk
+ self.currentChunk = chunk == null ? new Chunk(self, {'n':0}, self.writeConcern) : chunk;
+ self.currentChunk.position = self.currentChunk.data.length();
+ self.metadata = self.options['metadata'] == null ? self.metadata : self.options['metadata'];
+ self.aliases = self.options['aliases'] == null ? self.aliases : self.options['aliases'];
+ self.position = self.length;
+ callback(null, self);
+ });
+ }
+ }
+
+ // only pass error to callback once
+ function error (err) {
+ if(error.err) return;
+ callback(error.err = err);
+ }
+};
+
+/**
+ * @ignore
+ */
+var writeBuffer = function(self, buffer, close, callback) {
+ if(typeof close === "function") { callback = close; close = null; }
+ var finalClose = typeof close == 'boolean' ? close : false;
+
+ if(self.mode != "w") {
+ callback(new MongoError(f("file with id %s not opened for writing", (self.referenceBy == REFERENCE_BY_ID ? self.referenceBy : self.filename))), null);
+ } else {
+ if(self.currentChunk.position + buffer.length >= self.chunkSize) {
+ // Write out the current Chunk and then keep writing until we have less data left than a chunkSize left
+ // to a new chunk (recursively)
+ var previousChunkNumber = self.currentChunk.chunkNumber;
+ var leftOverDataSize = self.chunkSize - self.currentChunk.position;
+ var firstChunkData = buffer.slice(0, leftOverDataSize);
+ var leftOverData = buffer.slice(leftOverDataSize);
+ // A list of chunks to write out
+ var chunksToWrite = [self.currentChunk.write(firstChunkData)];
+ // If we have more data left than the chunk size let's keep writing new chunks
+ while(leftOverData.length >= self.chunkSize) {
+ // Create a new chunk and write to it
+ var newChunk = new Chunk(self, {'n': (previousChunkNumber + 1)}, self.writeConcern);
+ var firstChunkData = leftOverData.slice(0, self.chunkSize);
+ leftOverData = leftOverData.slice(self.chunkSize);
+ // Update chunk number
+ previousChunkNumber = previousChunkNumber + 1;
+ // Write data
+ newChunk.write(firstChunkData);
+ // Push chunk to save list
+ chunksToWrite.push(newChunk);
+ }
+
+ // Set current chunk with remaining data
+ self.currentChunk = new Chunk(self, {'n': (previousChunkNumber + 1)}, self.writeConcern);
+ // If we have left over data write it
+ if(leftOverData.length > 0) self.currentChunk.write(leftOverData);
+
+ // Update the position for the gridstore
+ self.position = self.position + buffer.length;
+ // Total number of chunks to write
+ var numberOfChunksToWrite = chunksToWrite.length;
+
+ for(var i = 0; i < chunksToWrite.length; i++) {
+ chunksToWrite[i].save({}, function(err, result) {
+ if(err) return callback(err);
+
+ numberOfChunksToWrite = numberOfChunksToWrite - 1;
+
+ if(numberOfChunksToWrite <= 0) {
+ // We care closing the file before returning
+ if(finalClose) {
+ return self.close(function(err, result) {
+ callback(err, self);
+ });
+ }
+
+ // Return normally
+ return callback(null, self);
+ }
+ });
+ }
+ } else {
+ // Update the position for the gridstore
+ self.position = self.position + buffer.length;
+ // We have less data than the chunk size just write it and callback
+ self.currentChunk.write(buffer);
+ // We care closing the file before returning
+ if(finalClose) {
+ return self.close(function(err, result) {
+ callback(err, self);
+ });
+ }
+ // Return normally
+ return callback(null, self);
+ }
+ }
+};
+
+/**
+ * Creates a mongoDB object representation of this object.
+ *
+ *
+ * {
+ * '_id' : , // {number} id for this file
+ * 'filename' : , // {string} name for this file
+ * 'contentType' : , // {string} mime type for this file
+ * 'length' : , // {number} size of this file?
+ * 'chunksize' : , // {number} chunk size used by this file
+ * 'uploadDate' : , // {Date}
+ * 'aliases' : , // {array of string}
+ * 'metadata' : , // {string}
+ * }
+ *
+ *
+ * @ignore
+ */
+var buildMongoObject = function(self, callback) {
+ // Calcuate the length
+ var mongoObject = {
+ '_id': self.fileId,
+ 'filename': self.filename,
+ 'contentType': self.contentType,
+ 'length': self.position ? self.position : 0,
+ 'chunkSize': self.chunkSize,
+ 'uploadDate': self.uploadDate,
+ 'aliases': self.aliases,
+ 'metadata': self.metadata
+ };
+
+ var md5Command = {filemd5:self.fileId, root:self.root};
+ self.db.command(md5Command, function(err, results) {
+ if(err) return callback(err);
+
+ mongoObject.md5 = results.md5;
+ callback(null, mongoObject);
+ });
+};
+
+/**
+ * Gets the nth chunk of this file.
+ * @ignore
+ */
+var nthChunk = function(self, chunkNumber, options, callback) {
+ if(typeof options == 'function') {
+ callback = options;
+ options = {};
+ }
+
+ options = options || self.writeConcern;
+ options.readPreference = self.readPreference;
+ // Get the nth chunk
+ self.chunkCollection().findOne({'files_id':self.fileId, 'n':chunkNumber}, options, function(err, chunk) {
+ if(err) return callback(err);
+
+ var finalChunk = chunk == null ? {} : chunk;
+ callback(null, new Chunk(self, finalChunk, self.writeConcern));
+ });
+};
+
+/**
+ * @ignore
+ */
+var lastChunkNumber = function(self) {
+ return Math.floor((self.length ? self.length - 1 : 0)/self.chunkSize);
+};
+
+/**
+ * Deletes all the chunks of this file in the database.
+ *
+ * @ignore
+ */
+var deleteChunks = function(self, options, callback) {
+ if(typeof options == 'function') {
+ callback = options;
+ options = {};
+ }
+
+ options = options || self.writeConcern;
+
+ if(self.fileId != null) {
+ self.chunkCollection().remove({'files_id':self.fileId}, options, function(err, result) {
+ if(err) return callback(err, false);
+ callback(null, true);
+ });
+ } else {
+ callback(null, true);
+ }
+};
+
+/**
+* The collection to be used for holding the files and chunks collection.
+*
+* @classconstant DEFAULT_ROOT_COLLECTION
+**/
+GridStore.DEFAULT_ROOT_COLLECTION = 'fs';
+
+/**
+* Default file mime type
+*
+* @classconstant DEFAULT_CONTENT_TYPE
+**/
+GridStore.DEFAULT_CONTENT_TYPE = 'binary/octet-stream';
+
+/**
+* Seek mode where the given length is absolute.
+*
+* @classconstant IO_SEEK_SET
+**/
+GridStore.IO_SEEK_SET = 0;
+
+/**
+* Seek mode where the given length is an offset to the current read/write head.
+*
+* @classconstant IO_SEEK_CUR
+**/
+GridStore.IO_SEEK_CUR = 1;
+
+/**
+* Seek mode where the given length is an offset to the end of the file.
+*
+* @classconstant IO_SEEK_END
+**/
+GridStore.IO_SEEK_END = 2;
+
+/**
+ * Checks if a file exists in the database.
+ *
+ * @method
+ * @static
+ * @param {Db} db the database to query.
+ * @param {string} name The name of the file to look for.
+ * @param {string} [rootCollection] The root collection that holds the files and chunks collection. Defaults to **{GridStore.DEFAULT_ROOT_COLLECTION}**.
+ * @param {object} [options=null] Optional settings.
+ * @param {(ReadPreference|string)} [options.readPreference=null] The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).
+ * @param {GridStore~resultCallback} callback result from exists.
+ * @return {null}
+ */
+GridStore.exist = function(db, fileIdObject, rootCollection, options, callback) {
+ var args = Array.prototype.slice.call(arguments, 2);
+ callback = args.pop();
+ rootCollection = args.length ? args.shift() : null;
+ options = args.length ? args.shift() : {};
+
+ // Establish read preference
+ var readPreference = options.readPreference || 'primary';
+ // Fetch collection
+ var rootCollectionFinal = rootCollection != null ? rootCollection : GridStore.DEFAULT_ROOT_COLLECTION;
+ db.collection(rootCollectionFinal + ".files", function(err, collection) {
+ if(err) return callback(err);
+
+ // Build query
+ var query = (typeof fileIdObject == 'string' || Object.prototype.toString.call(fileIdObject) == '[object RegExp]' )
+ ? {'filename':fileIdObject}
+ : {'_id':fileIdObject}; // Attempt to locate file
+
+ // We have a specific query
+ if(fileIdObject != null && typeof fileIdObject == 'object') {
+ query = fileIdObject;
+ }
+
+ // Check if the entry exists
+ collection.findOne(query, {readPreference:readPreference}, function(err, item) {
+ if(err) return callback(err);
+ callback(null, item == null ? false : true);
+ });
+ });
+};
+
+/**
+ * Gets the list of files stored in the GridFS.
+ *
+ * @method
+ * @static
+ * @param {Db} db the database to query.
+ * @param {string} [rootCollection] The root collection that holds the files and chunks collection. Defaults to **{GridStore.DEFAULT_ROOT_COLLECTION}**.
+ * @param {object} [options=null] Optional settings.
+ * @param {(ReadPreference|string)} [options.readPreference=null] The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).
+ * @param {GridStore~resultCallback} callback result from exists.
+ * @return {null}
+ */
+GridStore.list = function(db, rootCollection, options, callback) {
+ var args = Array.prototype.slice.call(arguments, 1);
+ callback = args.pop();
+ rootCollection = args.length ? args.shift() : null;
+ options = args.length ? args.shift() : {};
+
+ // Ensure we have correct values
+ if(rootCollection != null && typeof rootCollection == 'object') {
+ options = rootCollection;
+ rootCollection = null;
+ }
+
+ // Establish read preference
+ var readPreference = options.readPreference || 'primary';
+ // Check if we are returning by id not filename
+ var byId = options['id'] != null ? options['id'] : false;
+ // Fetch item
+ var rootCollectionFinal = rootCollection != null ? rootCollection : GridStore.DEFAULT_ROOT_COLLECTION;
+ var items = [];
+ db.collection((rootCollectionFinal + ".files"), function(err, collection) {
+ if(err) return callback(err);
+
+ collection.find({}, {readPreference:readPreference}, function(err, cursor) {
+ if(err) return callback(err);
+
+ cursor.each(function(err, item) {
+ if(item != null) {
+ items.push(byId ? item._id : item.filename);
+ } else {
+ callback(err, items);
+ }
+ });
+ });
+ });
+};
+
+/**
+ * Reads the contents of a file.
+ *
+ * This method has the following signatures
+ *
+ * (db, name, callback)
+ * (db, name, length, callback)
+ * (db, name, length, offset, callback)
+ * (db, name, length, offset, options, callback)
+ *
+ * @method
+ * @static
+ * @param {Db} db the database to query.
+ * @param {string} name The name of the file.
+ * @param {number} [length] The size of data to read.
+ * @param {number} [offset] The offset from the head of the file of which to start reading from.
+ * @param {object} [options=null] Optional settings.
+ * @param {(ReadPreference|string)} [options.readPreference=null] The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).
+ * @param {Gridstore~readCallback} callback the command callback.
+ * @return {null}
+ */
+
+GridStore.read = function(db, name, length, offset, options, callback) {
+ var args = Array.prototype.slice.call(arguments, 2);
+ callback = args.pop();
+ length = args.length ? args.shift() : null;
+ offset = args.length ? args.shift() : null;
+ options = args.length ? args.shift() : null;
+
+ new GridStore(db, name, "r", options).open(function(err, gridStore) {
+ if(err) return callback(err);
+ // Make sure we are not reading out of bounds
+ if(offset && offset >= gridStore.length) return callback("offset larger than size of file", null);
+ if(length && length > gridStore.length) return callback("length is larger than the size of the file", null);
+ if(offset && length && (offset + length) > gridStore.length) return callback("offset and length is larger than the size of the file", null);
+
+ if(offset != null) {
+ gridStore.seek(offset, function(err, gridStore) {
+ if(err) return callback(err);
+ gridStore.read(length, callback);
+ });
+ } else {
+ gridStore.read(length, callback);
+ }
+ });
+};
+
+/**
+ * Read the entire file as a list of strings splitting by the provided separator.
+ *
+ * @method
+ * @static
+ * @param {Db} db the database to query.
+ * @param {(String|object)} name the name of the file.
+ * @param {string} [separator] The character to be recognized as the newline separator.
+ * @param {object} [options=null] Optional settings.
+ * @param {(ReadPreference|string)} [options.readPreference=null] The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).
+ * @param {Gridstore~readlinesCallback} callback the command callback.
+ * @return {null}
+ */
+GridStore.readlines = function(db, name, separator, options, callback) {
+ var args = Array.prototype.slice.call(arguments, 2);
+ callback = args.pop();
+ separator = args.length ? args.shift() : null;
+ options = args.length ? args.shift() : null;
+
+ var finalSeperator = separator == null ? "\n" : separator;
+ new GridStore(db, name, "r", options).open(function(err, gridStore) {
+ if(err) return callback(err);
+ gridStore.readlines(finalSeperator, callback);
+ });
+};
+
+/**
+ * Deletes the chunks and metadata information of a file from GridFS.
+ *
+ * @method
+ * @static
+ * @param {Db} db The database to query.
+ * @param {(string|array)} names The name/names of the files to delete.
+ * @param {object} [options=null] Optional settings.
+ * @param {Gridstore~resultCallback} callback the command callback.
+ * @return {null}
+ */
+GridStore.unlink = function(db, names, options, callback) {
+ var self = this;
+ var args = Array.prototype.slice.call(arguments, 2);
+ callback = args.pop();
+ options = args.length ? args.shift() : {};
+
+ // Get the write concern
+ var writeConcern = _getWriteConcern(db, options);
+
+ // List of names
+ if(names.constructor == Array) {
+ var tc = 0;
+ for(var i = 0; i < names.length; i++) {
+ ++tc;
+ GridStore.unlink(db, names[i], options, function(result) {
+ if(--tc == 0) {
+ callback(null, self);
+ }
+ });
+ }
+ } else {
+ new GridStore(db, names, "w", options).open(function(err, gridStore) {
+ if(err) return callback(err);
+ deleteChunks(gridStore, function(err, result) {
+ if(err) return callback(err);
+ gridStore.collection(function(err, collection) {
+ if(err) return callback(err);
+ collection.remove({'_id':gridStore.fileId}, writeConcern, function(err, result) {
+ callback(err, self);
+ });
+ });
+ });
+ });
+ }
+};
+
+/**
+ * @ignore
+ */
+var _writeNormal = function(self, data, close, callback) {
+ // If we have a buffer write it using the writeBuffer method
+ if(Buffer.isBuffer(data)) {
+ return writeBuffer(self, data, close, callback);
+ } else {
+ return writeBuffer(self, new Buffer(data, 'binary'), close, callback);
+ }
+}
+
+/**
+ * @ignore
+ */
+var _setWriteConcernHash = function(options) {
+ var finalOptions = {};
+ if(options.w != null) finalOptions.w = options.w;
+ if(options.journal == true) finalOptions.j = options.journal;
+ if(options.j == true) finalOptions.j = options.j;
+ if(options.fsync == true) finalOptions.fsync = options.fsync;
+ if(options.wtimeout != null) finalOptions.wtimeout = options.wtimeout;
+ return finalOptions;
+}
+
+/**
+ * @ignore
+ */
+var _getWriteConcern = function(self, options) {
+ // Final options
+ var finalOptions = {w:1};
+ options = options || {};
+
+ // Local options verification
+ if(options.w != null || typeof options.j == 'boolean' || typeof options.journal == 'boolean' || typeof options.fsync == 'boolean') {
+ finalOptions = _setWriteConcernHash(options);
+ } else if(options.safe != null && typeof options.safe == 'object') {
+ finalOptions = _setWriteConcernHash(options.safe);
+ } else if(typeof options.safe == "boolean") {
+ finalOptions = {w: (options.safe ? 1 : 0)};
+ } else if(self.options.w != null || typeof self.options.j == 'boolean' || typeof self.options.journal == 'boolean' || typeof self.options.fsync == 'boolean') {
+ finalOptions = _setWriteConcernHash(self.options);
+ } else if(self.safe && (self.safe.w != null || typeof self.safe.j == 'boolean' || typeof self.safe.journal == 'boolean' || typeof self.safe.fsync == 'boolean')) {
+ finalOptions = _setWriteConcernHash(self.safe);
+ } else if(typeof self.safe == "boolean") {
+ finalOptions = {w: (self.safe ? 1 : 0)};
+ }
+
+ // Ensure we don't have an invalid combination of write concerns
+ if(finalOptions.w < 1
+ && (finalOptions.journal == true || finalOptions.j == true || finalOptions.fsync == true)) throw new MongoError("No acknowledgement using w < 1 cannot be combined with journal:true or fsync:true");
+
+ // Return the options
+ return finalOptions;
+}
+
+/**
+ * Create a new GridStoreStream instance (INTERNAL TYPE, do not instantiate directly)
+ *
+ * @class
+ * @extends external:Duplex
+ * @return {GridStoreStream} a GridStoreStream instance.
+ */
+var GridStoreStream = function(gs) {
+ var self = this;
+ // Initialize the duplex stream
+ Duplex.call(this);
+
+ // Get the gridstore
+ this.gs = gs;
+
+ // End called
+ this.endCalled = false;
+
+ // If we have a seek
+ this.totalBytesToRead = this.gs.length - this.gs.position;
+ this.seekPosition = this.gs.position;
+}
+
+//
+// Inherit duplex
+inherits(GridStoreStream, Duplex);
+
+GridStoreStream.prototype._pipe = GridStoreStream.prototype.pipe;
+
+// Set up override
+GridStoreStream.prototype.pipe = function(destination) {
+ var self = this;
+ self.gs.open(function(err) {
+ if(err) return self.emit('error', err);
+ self.totalBytesToRead = self.gs.length - self.gs.position;
+ self._pipe.apply(self, [destination]);
+ });
+}
+
+// Called by stream
+GridStoreStream.prototype._read = function(n) {
+ var self = this;
+ // Set read length
+ var length = self.gs.length < self.gs.chunkSize ? self.gs.length - self.seekPosition : self.gs.chunkSize;
+ // Read data
+ self.gs.read(length, function(err, buffer) {
+ // Stream is closed
+ if(self.endCalled || buffer == null) return self.push(null);
+ // Remove bytes read
+ if(buffer.length <= self.totalBytesToRead) {
+ self.totalBytesToRead = self.totalBytesToRead - buffer.length;
+ self.push(buffer);
+ } else if(buffer.length > self.totalBytesToRead) {
+ self.push(buffer.slice(0, buffer._index));
+ self.totalBytesToRead = self.totalBytesToRead - buffer._index;
+ }
+
+ // Finished reading
+ if(self.totalBytesToRead <= 0) {
+ self.endCalled = true;
+ }
+ });
+}
+
+GridStoreStream.prototype.destroy = function() {
+ this.pause();
+ this.endCalled = true;
+ this.gs.close();
+ this.emit('end');
+}
+
+GridStoreStream.prototype.write = function(chunk, encoding, callback) {
+ var self = this;
+ if(self.endCalled) return self.emit('error', new MongoError('attempting to write to stream after end called'))
+ // Do we have to open the gridstore
+ if(!self.gs.isOpen) {
+ self.gs.open(function() {
+ self.gs.isOpen = true;
+ self.gs.write(chunk, function() {
+ self.emit('drain');
+ });
+ });
+ } else {
+ self.gs.write(chunk, function() {
+ self.emit('drain');
+ });
+ }
+
+ return false;
+}
+
+GridStoreStream.prototype.end = function(chunk, encoding, callback) {
+ var self = this;
+ var args = Array.prototype.slice.call(arguments, 0);
+ callback = args.pop();
+ chunk = args.length ? args.shift() : null;
+ encoding = args.length ? args.shift() : null;
+ self.endCalled = true;
+
+ if(chunk) {
+ self.gs.write(chunk, function() {
+ self.gs.close(function() {
+ if(typeof callback == 'function') callback();
+ self.emit('end')
+ });
+ });
+ }
+
+ self.gs.close(function() {
+ if(typeof callback == 'function') callback();
+ self.emit('end')
+ });
+}
+
+/**
+ * The read() method pulls some data out of the internal buffer and returns it. If there is no data available, then it will return null.
+ * @function external:Duplex#read
+ * @param {number} size Optional argument to specify how much data to read.
+ * @return {(String | Buffer | null)}
+ */
+
+/**
+ * Call this function to cause the stream to return strings of the specified encoding instead of Buffer objects.
+ * @function external:Duplex#setEncoding
+ * @param {string} encoding The encoding to use.
+ * @return {null}
+ */
+
+/**
+ * This method will cause the readable stream to resume emitting data events.
+ * @function external:Duplex#resume
+ * @return {null}
+ */
+
+/**
+ * This method will cause a stream in flowing-mode to stop emitting data events. Any data that becomes available will remain in the internal buffer.
+ * @function external:Duplex#pause
+ * @return {null}
+ */
+
+/**
+ * This method pulls all the data out of a readable stream, and writes it to the supplied destination, automatically managing the flow so that the destination is not overwhelmed by a fast readable stream.
+ * @function external:Duplex#pipe
+ * @param {Writable} destination The destination for writing data
+ * @param {object} [options] Pipe options
+ * @return {null}
+ */
+
+/**
+ * This method will remove the hooks set up for a previous pipe() call.
+ * @function external:Duplex#unpipe
+ * @param {Writable} [destination] The destination for writing data
+ * @return {null}
+ */
+
+/**
+ * This is useful in certain cases where a stream is being consumed by a parser, which needs to "un-consume" some data that it has optimistically pulled out of the source, so that the stream can be passed on to some other party.
+ * @function external:Duplex#unshift
+ * @param {(Buffer|string)} chunk Chunk of data to unshift onto the read queue.
+ * @return {null}
+ */
+
+/**
+ * Versions of Node prior to v0.10 had streams that did not implement the entire Streams API as it is today. (See "Compatibility" below for more information.)
+ * @function external:Duplex#wrap
+ * @param {Stream} stream An "old style" readable stream.
+ * @return {null}
+ */
+
+/**
+ * This method writes some data to the underlying system, and calls the supplied callback once the data has been fully handled.
+ * @function external:Duplex#write
+ * @param {(string|Buffer)} chunk The data to write
+ * @param {string} encoding The encoding, if chunk is a String
+ * @param {function} callback Callback for when this chunk of data is flushed
+ * @return {boolean}
+ */
+
+/**
+ * Call this method when no more data will be written to the stream. If supplied, the callback is attached as a listener on the finish event.
+ * @function external:Duplex#end
+ * @param {(string|Buffer)} chunk The data to write
+ * @param {string} encoding The encoding, if chunk is a String
+ * @param {function} callback Callback for when this chunk of data is flushed
+ * @return {null}
+ */
+
+/**
+ * GridStoreStream stream data event, fired for each document in the cursor.
+ *
+ * @event GridStoreStream#data
+ * @type {object}
+ */
+
+/**
+ * GridStoreStream stream end event
+ *
+ * @event GridStoreStream#end
+ * @type {null}
+ */
+
+/**
+ * GridStoreStream stream close event
+ *
+ * @event GridStoreStream#close
+ * @type {null}
+ */
+
+/**
+ * GridStoreStream stream readable event
+ *
+ * @event GridStoreStream#readable
+ * @type {null}
+ */
+
+/**
+ * GridStoreStream stream drain event
+ *
+ * @event GridStoreStream#drain
+ * @type {null}
+ */
+
+/**
+ * GridStoreStream stream finish event
+ *
+ * @event GridStoreStream#finish
+ * @type {null}
+ */
+
+/**
+ * GridStoreStream stream pipe event
+ *
+ * @event GridStoreStream#pipe
+ * @type {null}
+ */
+
+/**
+ * GridStoreStream stream unpipe event
+ *
+ * @event GridStoreStream#unpipe
+ * @type {null}
+ */
+
+/**
+ * GridStoreStream stream error event
+ *
+ * @event GridStoreStream#error
+ * @type {null}
+ */
+
+/**
+ * @ignore
+ */
+module.exports = GridStore;
diff --git a/server/node_modules/mongodb/lib/mongo_client.js b/server/node_modules/mongodb/lib/mongo_client.js
new file mode 100755
index 00000000..7f5f7a2c
--- /dev/null
+++ b/server/node_modules/mongodb/lib/mongo_client.js
@@ -0,0 +1,413 @@
+"use strict";
+
+var parse = require('./url_parser')
+ , Server = require('./server')
+ , Mongos = require('./mongos')
+ , ReplSet = require('./replset')
+ , ReadPreference = require('./read_preference')
+ , Db = require('./db');
+
+/**
+ * @fileOverview The **MongoClient** class is a class that allows for making Connections to MongoDB.
+ *
+ * @example
+ * var MongoClient = require('mongodb').MongoClient,
+ * test = require('assert');
+ * // Connection url
+ * var url = 'mongodb://localhost:27017/test';
+ * // Connect using MongoClient
+ * MongoClient.connect(url, function(err, db) {
+ * // Get an additional db
+ * db.close();
+ * });
+ */
+
+/**
+ * Creates a new MongoClient instance
+ * @class
+ * @return {MongoClient} a MongoClient instance.
+ */
+function MongoClient() {
+ /**
+ * The callback format for results
+ * @callback MongoClient~connectCallback
+ * @param {MongoError} error An error instance representing the error during the execution.
+ * @param {Db} db The connected database.
+ */
+
+ /**
+ * Connect to MongoDB using a url as documented at
+ *
+ * docs.mongodb.org/manual/reference/connection-string/
+ *
+ * Note that for replicasets the replicaSet query parameter is required in the 2.0 driver
+ *
+ * @method
+ * @param {string} url The connection URI string
+ * @param {object} [options=null] Optional settings.
+ * @param {boolean} [options.uri_decode_auth=false] Uri decode the user name and password for authentication
+ * @param {object} [options.db=null] A hash of options to set on the db object, see **Db constructor**
+ * @param {object} [options.server=null] A hash of options to set on the server objects, see **Server** constructor**
+ * @param {object} [options.replSet=null] A hash of options to set on the replSet object, see **ReplSet** constructor**
+ * @param {object} [options.mongos=null] A hash of options to set on the mongos object, see **Mongos** constructor**
+ * @param {MongoClient~connectCallback} callback The command result callback
+ * @return {null}
+ */
+ this.connect = MongoClient.connect;
+}
+
+/**
+ * Connect to MongoDB using a url as documented at
+ *
+ * docs.mongodb.org/manual/reference/connection-string/
+ *
+ * Note that for replicasets the replicaSet query parameter is required in the 2.0 driver
+ *
+ * @method
+ * @static
+ * @param {string} url The connection URI string
+ * @param {object} [options=null] Optional settings.
+ * @param {boolean} [options.uri_decode_auth=false] Uri decode the user name and password for authentication
+ * @param {object} [options.db=null] A hash of options to set on the db object, see **Db constructor**
+ * @param {object} [options.server=null] A hash of options to set on the server objects, see **Server** constructor**
+ * @param {object} [options.replSet=null] A hash of options to set on the replSet object, see **ReplSet** constructor**
+ * @param {object} [options.mongos=null] A hash of options to set on the mongos object, see **Mongos** constructor**
+ * @param {MongoClient~connectCallback} callback The command result callback
+ * @return {null}
+ */
+MongoClient.connect = function(url, options, callback) {
+ var args = Array.prototype.slice.call(arguments, 1);
+ callback = typeof args[args.length - 1] == 'function' ? args.pop() : null;
+ options = args.length ? args.shift() : null;
+ options = options || {};
+
+ // Set default empty server options
+ var serverOptions = options.server || {};
+ var mongosOptions = options.mongos || {};
+ var replSetServersOptions = options.replSet || options.replSetServers || {};
+ var dbOptions = options.db || {};
+
+ // If callback is null throw an exception
+ if(callback == null)
+ throw new Error("no callback function provided");
+
+ // Parse the string
+ var object = parse(url, options);
+
+ // Merge in any options for db in options object
+ if(dbOptions) {
+ for(var name in dbOptions) object.db_options[name] = dbOptions[name];
+ }
+
+ // Added the url to the options
+ object.db_options.url = url;
+
+ // Merge in any options for server in options object
+ if(serverOptions) {
+ for(var name in serverOptions) object.server_options[name] = serverOptions[name];
+ }
+
+ // Merge in any replicaset server options
+ if(replSetServersOptions) {
+ for(var name in replSetServersOptions) object.rs_options[name] = replSetServersOptions[name];
+ }
+
+ if(replSetServersOptions.ssl
+ || replSetServersOptions.sslValidate
+ || replSetServersOptions.sslCA
+ || replSetServersOptions.sslCert
+ || replSetServersOptions.sslKey
+ || replSetServersOptions.sslPass) {
+ object.server_options.ssl = replSetServersOptions.ssl;
+ object.server_options.sslValidate = replSetServersOptions.sslValidate;
+ object.server_options.sslCA = replSetServersOptions.sslCA;
+ object.server_options.sslCert = replSetServersOptions.sslCert;
+ object.server_options.sslKey = replSetServersOptions.sslKey;
+ object.server_options.sslPass = replSetServersOptions.sslPass;
+ }
+
+ // Merge in any replicaset server options
+ if(mongosOptions) {
+ for(var name in mongosOptions) object.mongos_options[name] = mongosOptions[name];
+ }
+
+ if(typeof object.server_options.poolSize == 'number') {
+ if(!object.mongos_options.poolSize) object.mongos_options.poolSize = object.server_options.poolSize;
+ if(!object.rs_options.poolSize) object.rs_options.poolSize = object.server_options.poolSize;
+ }
+
+ if(mongosOptions.ssl
+ || mongosOptions.sslValidate
+ || mongosOptions.sslCA
+ || mongosOptions.sslCert
+ || mongosOptions.sslKey
+ || mongosOptions.sslPass) {
+ object.server_options.ssl = mongosOptions.ssl;
+ object.server_options.sslValidate = mongosOptions.sslValidate;
+ object.server_options.sslCA = mongosOptions.sslCA;
+ object.server_options.sslCert = mongosOptions.sslCert;
+ object.server_options.sslKey = mongosOptions.sslKey;
+ object.server_options.sslPass = mongosOptions.sslPass;
+ }
+
+ // We need to ensure that the list of servers are only either direct members or mongos
+ // they cannot be a mix of monogs and mongod's
+ var totalNumberOfServers = object.servers.length;
+ var totalNumberOfMongosServers = 0;
+ var totalNumberOfMongodServers = 0;
+ var serverConfig = null;
+ var errorServers = {};
+
+ // Failure modes
+ if(object.servers.length == 0) throw new Error("connection string must contain at least one seed host");
+
+ // If we have no db setting for the native parser try to set the c++ one first
+ object.db_options.native_parser = _setNativeParser(object.db_options);
+ // If no auto_reconnect is set, set it to true as default for single servers
+ if(typeof object.server_options.auto_reconnect != 'boolean') {
+ object.server_options.auto_reconnect = true;
+ }
+
+ // If we have more than a server, it could be replicaset or mongos list
+ // need to verify that it's one or the other and fail if it's a mix
+ // Connect to all servers and run ismaster
+ for(var i = 0; i < object.servers.length; i++) {
+ // Set up socket options
+ var providedSocketOptions = object.server_options.socketOptions || {};
+
+ var _server_options = {
+ poolSize:1
+ , socketOptions: {
+ connectTimeoutMS: providedSocketOptions.connectTimeoutMS || 30000
+ , socketTimeoutMS: providedSocketOptions.socketTimeoutMS || 30000
+ }
+ , auto_reconnect:false};
+
+ // Ensure we have ssl setup for the servers
+ if(object.server_options.ssl) {
+ _server_options.ssl = object.server_options.ssl;
+ _server_options.sslValidate = object.server_options.sslValidate;
+ _server_options.sslCA = object.server_options.sslCA;
+ _server_options.sslCert = object.server_options.sslCert;
+ _server_options.sslKey = object.server_options.sslKey;
+ _server_options.sslPass = object.server_options.sslPass;
+ } else if(object.rs_options.ssl) {
+ _server_options.ssl = object.rs_options.ssl;
+ _server_options.sslValidate = object.rs_options.sslValidate;
+ _server_options.sslCA = object.rs_options.sslCA;
+ _server_options.sslCert = object.rs_options.sslCert;
+ _server_options.sslKey = object.rs_options.sslKey;
+ _server_options.sslPass = object.rs_options.sslPass;
+ }
+
+ // Error
+ var error = null;
+ // Set up the Server object
+ var _server = object.servers[i].domain_socket
+ ? new Server(object.servers[i].domain_socket, _server_options)
+ : new Server(object.servers[i].host, object.servers[i].port, _server_options);
+
+ var setName;
+
+ var connectFunction = function(__server) {
+ // Attempt connect
+ new Db(object.dbName, __server, {w:1, native_parser:false}).open(function(err, db) {
+ // Update number of servers
+ totalNumberOfServers = totalNumberOfServers - 1;
+ // If no error do the correct checks
+ if(!err) {
+ // Close the connection
+ db.close();
+ var isMasterDoc = db.serverConfig.isMasterDoc;
+ // Check what type of server we have
+ if(isMasterDoc.setName) {
+ totalNumberOfMongodServers++;
+ setName = isMasterDoc.setName;
+ }
+ if(isMasterDoc.msg && isMasterDoc.msg == "isdbgrid") totalNumberOfMongosServers++;
+ } else {
+ error = err;
+ errorServers[__server.host + ":" + __server.port] = __server;
+ }
+
+ if(totalNumberOfServers == 0) {
+ // Error out
+ if(totalNumberOfMongodServers == 0 && totalNumberOfMongosServers == 0 && error) {
+ return callback(error, null);
+ }
+
+ // If we have a mix of mongod and mongos, throw an error
+ if(totalNumberOfMongosServers > 0 && totalNumberOfMongodServers > 0) {
+ if(db) db.close();
+ return process.nextTick(function() {
+ try {
+ callback(new Error("cannot combine a list of replicaset seeds and mongos seeds"));
+ } catch (err) {
+ throw err
+ }
+ })
+ }
+
+ if(totalNumberOfMongodServers == 0
+ && totalNumberOfMongosServers == 0
+ && object.servers.length == 1) {
+ var obj = object.servers[0];
+ serverConfig = obj.domain_socket ?
+ new Server(obj.domain_socket, object.server_options)
+ : new Server(obj.host, obj.port, object.server_options);
+ } else if(totalNumberOfMongodServers > 0 || totalNumberOfMongosServers > 0) {
+ var finalServers = object.servers
+ .filter(function(serverObj) {
+ return errorServers[serverObj.host + ":" + serverObj.port] == null;
+ })
+ .map(function(serverObj) {
+ return new Server(serverObj.host, serverObj.port, object.server_options);
+ });
+ // Clean out any error servers
+ errorServers = {};
+ // Set up the final configuration
+ if(totalNumberOfMongodServers > 0) {
+ try {
+ if (totalNumberOfMongodServers == 1) {
+ object.rs_options.replicaSet = object.rs_options.replicaSet || setName;
+ }
+ serverConfig = new ReplSet(finalServers, object.rs_options);
+ } catch(err) {
+ return callback(err, null);
+ }
+ } else {
+ serverConfig = new Mongos(finalServers, object.mongos_options);
+ }
+ }
+
+ if(serverConfig == null) {
+ return process.nextTick(function() {
+ try {
+ callback(new Error("Could not locate any valid servers in initial seed list"));
+ } catch (err) {
+ if(db) db.close();
+ throw err
+ }
+ });
+ }
+
+ // Ensure no firing of open event before we are ready
+ serverConfig.emitOpen = false;
+ // Set up all options etc and connect to the database
+ _finishConnecting(serverConfig, object, options, callback)
+ }
+ });
+ }
+
+ // Wrap the context of the call
+ connectFunction(_server);
+ }
+}
+
+var _setNativeParser = function(db_options) {
+ if(typeof db_options.native_parser == 'boolean') return db_options.native_parser;
+
+ try {
+ require('mongodb-core').BSON.BSONNative.BSON;
+ return true;
+ } catch(err) {
+ return false;
+ }
+}
+
+var _finishConnecting = function(serverConfig, object, options, callback) {
+ // If we have a readPreference passed in by the db options
+ if(typeof object.db_options.readPreference == 'string') {
+ object.db_options.readPreference = new ReadPreference(object.db_options.readPreference);
+ } else if(typeof object.db_options.read_preference == 'string') {
+ object.db_options.readPreference = new ReadPreference(object.db_options.read_preference);
+ }
+
+ // Do we have readPreference tags
+ if(object.db_options.readPreference && object.db_options.readPreferenceTags) {
+ object.db_options.readPreference.tags = object.db_options.readPreferenceTags;
+ } else if(object.db_options.readPreference && object.db_options.read_preference_tags) {
+ object.db_options.readPreference.tags = object.db_options.read_preference_tags;
+ }
+
+ // Get the socketTimeoutMS
+ var socketTimeoutMS = object.server_options.socketOptions.socketTimeoutMS || 0;
+
+ // If we have a replset, override with replicaset socket timeout option if available
+ if(serverConfig instanceof ReplSet) {
+ socketTimeoutMS = object.rs_options.socketOptions.socketTimeoutMS || socketTimeoutMS;
+ }
+
+ // Set socketTimeout to the same as the connectTimeoutMS or 30 sec
+ serverConfig.connectTimeoutMS = serverConfig.connectTimeoutMS || 30000;
+ serverConfig.socketTimeoutMS = serverConfig.connectTimeoutMS;
+
+ // Set up the db options
+ var db = new Db(object.dbName, serverConfig, object.db_options);
+ // Open the db
+ db.open(function(err, db){
+
+ if(err) {
+ return process.nextTick(function() {
+ try {
+ callback(err, null);
+ } catch (err) {
+ if(db) db.close();
+ throw err
+ }
+ });
+ }
+
+ // Reset the socket timeout
+ serverConfig.socketTimeoutMS = socketTimeoutMS || 0;
+
+ // Return object
+ if(err == null && object.auth){
+ // What db to authenticate against
+ var authentication_db = db;
+ if(object.db_options && object.db_options.authSource) {
+ authentication_db = db.db(object.db_options.authSource);
+ }
+
+ // Build options object
+ var options = {};
+ if(object.db_options.authMechanism) options.authMechanism = object.db_options.authMechanism;
+ if(object.db_options.gssapiServiceName) options.gssapiServiceName = object.db_options.gssapiServiceName;
+
+ // Authenticate
+ authentication_db.authenticate(object.auth.user, object.auth.password, options, function(err, success){
+ if(success){
+ process.nextTick(function() {
+ try {
+ callback(null, db);
+ } catch (err) {
+ if(db) db.close();
+ throw err
+ }
+ });
+ } else {
+ if(db) db.close();
+ process.nextTick(function() {
+ try {
+ callback(err ? err : new Error('Could not authenticate user ' + object.auth[0]), null);
+ } catch (err) {
+ if(db) db.close();
+ throw err
+ }
+ });
+ }
+ });
+ } else {
+ process.nextTick(function() {
+ try {
+ callback(err, db);
+ } catch (err) {
+ if(db) db.close();
+ throw err
+ }
+ })
+ }
+ });
+}
+
+module.exports = MongoClient
diff --git a/server/node_modules/mongodb/lib/mongos.js b/server/node_modules/mongodb/lib/mongos.js
new file mode 100755
index 00000000..88913c0e
--- /dev/null
+++ b/server/node_modules/mongodb/lib/mongos.js
@@ -0,0 +1,454 @@
+"use strict";
+
+var EventEmitter = require('events').EventEmitter
+ , inherits = require('util').inherits
+ , f = require('util').format
+ , ServerCapabilities = require('./topology_base').ServerCapabilities
+ , MongoCR = require('mongodb-core').MongoCR
+ , CMongos = require('mongodb-core').Mongos
+ , Cursor = require('./cursor')
+ , Server = require('./server')
+ , Store = require('./topology_base').Store
+ , shallowClone = require('./utils').shallowClone;
+
+/**
+ * @fileOverview The **Mongos** class is a class that represents a Mongos Proxy topology and is
+ * used to construct connections.
+ *
+ * **Mongos Should not be used, use MongoClient.connect**
+ * @example
+ * var Db = require('mongodb').Db,
+ * Mongos = require('mongodb').Mongos,
+ * Server = require('mongodb').Server,
+ * test = require('assert');
+ * // Connect using Mongos
+ * var server = new Server('localhost', 27017);
+ * var db = new Db('test', new Mongos([server]));
+ * db.open(function(err, db) {
+ * // Get an additional db
+ * db.close();
+ * });
+ */
+
+/**
+ * Creates a new Mongos instance
+ * @class
+ * @deprecated
+ * @param {Server[]} servers A seedlist of servers participating in the replicaset.
+ * @param {object} [options=null] Optional settings.
+ * @param {booelan} [options.ha=true] Turn on high availability monitoring.
+ * @param {number} [options.haInterval=5000] Time between each replicaset status check.
+ * @param {number} [options.poolSize=5] Number of connections in the connection pool for each server instance, set to 5 as default for legacy reasons.
+ * @param {boolean} [options.ssl=false] Use ssl connection (needs to have a mongod server with ssl support)
+ * @param {object} [options.sslValidate=true] Validate mongod server certificate against ca (needs to have a mongod server with ssl support, 2.4 or higher)
+ * @param {array} [options.sslCA=null] Array of valid certificates either as Buffers or Strings (needs to have a mongod server with ssl support, 2.4 or higher)
+ * @param {(Buffer|string)} [options.sslCert=null] String or buffer containing the certificate we wish to present (needs to have a mongod server with ssl support, 2.4 or higher)
+ * @param {(Buffer|string)} [options.sslKey=null] String or buffer containing the certificate private key we wish to present (needs to have a mongod server with ssl support, 2.4 or higher)
+ * @param {(Buffer|string)} [options.sslPass=null] String or buffer containing the certificate password (needs to have a mongod server with ssl support, 2.4 or higher)
+ * @param {object} [options.socketOptions=null] Socket options
+ * @param {boolean} [options.socketOptions.noDelay=true] TCP Socket NoDelay option.
+ * @param {number} [options.socketOptions.keepAlive=0] TCP KeepAlive on the socket with a X ms delay before start.
+ * @param {number} [options.socketOptions.connectTimeoutMS=0] TCP Connection timeout setting
+ * @param {number} [options.socketOptions.socketTimeoutMS=0] TCP Socket timeout setting
+ * @fires Mongos#connect
+ * @fires Mongos#ha
+ * @fires Mongos#joined
+ * @fires Mongos#left
+ * @fires Mongos#fullsetup
+ * @fires Mongos#open
+ * @fires Mongos#close
+ * @fires Mongos#error
+ * @fires Mongos#timeout
+ * @fires Mongos#parseError
+ * @return {Mongos} a Mongos instance.
+ */
+var Mongos = function(servers, options) {
+ if(!(this instanceof Mongos)) return new Mongos(servers, options);
+ options = options || {};
+ var self = this;
+
+ // Ensure all the instances are Server
+ for(var i = 0; i < servers.length; i++) {
+ if(!(servers[i] instanceof Server)) {
+ throw new MongoError("all seed list instances must be of the Server type");
+ }
+ }
+
+ // Store option defaults
+ var storeOptions = {
+ force: false
+ , bufferMaxEntries: -1
+ }
+
+ // Shared global store
+ var store = options.store || new Store(self, storeOptions);
+
+ // Set up event emitter
+ EventEmitter.call(this);
+
+ // Debug tag
+ var tag = options.tag;
+
+ // Build seed list
+ var seedlist = servers.map(function(x) {
+ return {host: x.host, port: x.port}
+ });
+
+ // Final options
+ var finalOptions = shallowClone(options);
+
+ // Default values
+ finalOptions.size = typeof options.poolSize == 'number' ? options.poolSize : 5;
+ finalOptions.reconnect = typeof options.auto_reconnect == 'boolean' ? options.auto_reconnect : true;
+ finalOptions.emitError = typeof options.emitError == 'boolean' ? options.emitError : true;
+ finalOptions.cursorFactory = Cursor;
+
+ // Add the store
+ finalOptions.disconnectHandler = store;
+
+ // Socket options passed down
+ if(options.socketOptions) {
+ if(options.socketOptions.connectTimeoutMS) {
+ this.connectTimeoutMS = options.socketOptions.connectTimeoutMS;
+ finalOptions.connectionTimeout = options.socketOptions.connectTimeoutMS;
+ }
+ if(options.socketOptions.socketTimeoutMS)
+ finalOptions.socketTimeout = options.socketOptions.socketTimeoutMS;
+ }
+
+ // Are we running in debug mode
+ var debug = typeof options.debug == 'boolean' ? options.debug : false;
+ if(debug) {
+ finalOptions.debug = debug;
+ }
+
+ // Map keep alive setting
+ if(options.socketOptions && typeof options.socketOptions.keepAlive == 'number') {
+ finalOptions.keepAlive = true;
+ if(typeof options.socketOptions.keepAlive == 'number') {
+ finalOptions.keepAliveInitialDelay = options.socketOptions.keepAlive;
+ }
+ }
+
+ // Connection timeout
+ if(options.socketOptions && typeof options.socketOptions.connectionTimeout == 'number') {
+ finalOptions.connectionTimeout = options.socketOptions.connectionTimeout;
+ }
+
+ // Socket timeout
+ if(options.socketOptions && typeof options.socketOptions.socketTimeout == 'number') {
+ finalOptions.socketTimeout = options.socketOptions.socketTimeout;
+ }
+
+ // noDelay
+ if(options.socketOptions && typeof options.socketOptions.noDelay == 'boolean') {
+ finalOptions.noDelay = options.socketOptions.noDelay;
+ }
+
+ if(typeof options.secondaryAcceptableLatencyMS == 'number') {
+ finalOptions.acceptableLatency = options.secondaryAcceptableLatencyMS;
+ }
+
+ // Add the non connection store
+ finalOptions.disconnectHandler = store;
+
+ // Create the Mongos
+ var mongos = new CMongos(seedlist, finalOptions)
+ // Server capabilities
+ var sCapabilities = null;
+ // Add auth prbufferMaxEntriesoviders
+ mongos.addAuthProvider('mongocr', new MongoCR());
+
+ // Internal state
+ this.s = {
+ // Create the Mongos
+ mongos: mongos
+ // Server capabilities
+ , sCapabilities: sCapabilities
+ // Debug turned on
+ , debug: debug
+ // Store option defaults
+ , storeOptions: storeOptions
+ // Cloned options
+ , clonedOptions: finalOptions
+ // Actual store of callbacks
+ , store: store
+ // Options
+ , options: options
+ }
+
+
+ // Last ismaster
+ Object.defineProperty(this, 'isMasterDoc', {
+ enumerable:true, get: function() { return self.s.mongos.lastIsMaster(); }
+ });
+
+ // Last ismaster
+ Object.defineProperty(this, 'numberOfConnectedServers', {
+ enumerable:true, get: function() { return self.s.mongos.connectedServers().length; }
+ });
+
+ // BSON property
+ Object.defineProperty(this, 'bson', {
+ enumerable: true, get: function() {
+ return self.s.mongos.bson;
+ }
+ });
+
+ Object.defineProperty(this, 'haInterval', {
+ enumerable:true, get: function() { return self.s.mongos.haInterval; }
+ });
+}
+
+/**
+ * @ignore
+ */
+inherits(Mongos, EventEmitter);
+
+// Connect
+Mongos.prototype.connect = function(db, _options, callback) {
+ var self = this;
+ if('function' === typeof _options) callback = _options, _options = {};
+ if(_options == null) _options = {};
+ if(!('function' === typeof callback)) callback = null;
+ self.s.options = _options;
+
+ // Update bufferMaxEntries
+ self.s.storeOptions.bufferMaxEntries = db.bufferMaxEntries;
+
+ // Error handler
+ var connectErrorHandler = function(event) {
+ return function(err) {
+ // Remove all event handlers
+ var events = ['timeout', 'error', 'close'];
+ events.forEach(function(e) {
+ self.removeListener(e, connectErrorHandler);
+ });
+
+ self.s.mongos.removeListener('connect', connectErrorHandler);
+
+ // Try to callback
+ try {
+ callback(err);
+ } catch(err) {
+ process.nextTick(function() { throw err; })
+ }
+ }
+ }
+
+ // Actual handler
+ var errorHandler = function(event) {
+ return function(err) {
+ if(event != 'error') {
+ self.emit(event, err);
+ }
+ }
+ }
+
+ // Error handler
+ var reconnectHandler = function(err) {
+ self.emit('reconnect');
+ self.s.store.execute();
+ }
+
+ // Connect handler
+ var connectHandler = function() {
+ // Clear out all the current handlers left over
+ ["timeout", "error", "close"].forEach(function(e) {
+ self.s.mongos.removeAllListeners(e);
+ });
+
+ // Set up listeners
+ self.s.mongos.once('timeout', errorHandler('timeout'));
+ self.s.mongos.once('error', errorHandler('error'));
+ self.s.mongos.once('close', errorHandler('close'));
+
+ // relay the event
+ var relay = function(event) {
+ return function(t, server) {
+ self.emit(event, t, server);
+ }
+ }
+
+ // Set up serverConfig listeners
+ self.s.mongos.on('joined', relay('joined'));
+ self.s.mongos.on('left', relay('left'));
+ self.s.mongos.on('fullsetup', relay('fullsetup'));
+
+ // Emit open event
+ self.emit('open', null, self);
+
+ // Return correctly
+ try {
+ callback(null, self);
+ } catch(err) {
+ process.nextTick(function() { throw err; })
+ }
+ }
+
+ // Set up listeners
+ self.s.mongos.once('timeout', connectErrorHandler('timeout'));
+ self.s.mongos.once('error', connectErrorHandler('error'));
+ self.s.mongos.once('close', connectErrorHandler('close'));
+ self.s.mongos.once('connect', connectHandler);
+ // Reconnect server
+ self.s.mongos.on('reconnect', reconnectHandler);
+
+ // Start connection
+ self.s.mongos.connect(_options);
+}
+
+Mongos.prototype.parserType = function() {
+ return this.s.mongos.parserType();
+}
+
+// Server capabilities
+Mongos.prototype.capabilities = function() {
+ if(this.s.sCapabilities) return this.s.sCapabilities;
+ this.s.sCapabilities = new ServerCapabilities(this.s.mongos.lastIsMaster());
+ return this.s.sCapabilities;
+}
+
+// Command
+Mongos.prototype.command = function(ns, cmd, options, callback) {
+ this.s.mongos.command(ns, cmd, options, callback);
+}
+
+// Insert
+Mongos.prototype.insert = function(ns, ops, options, callback) {
+ this.s.mongos.insert(ns, ops, options, function(e, m) {
+ callback(e, m)
+ });
+}
+
+// Update
+Mongos.prototype.update = function(ns, ops, options, callback) {
+ this.s.mongos.update(ns, ops, options, callback);
+}
+
+// Remove
+Mongos.prototype.remove = function(ns, ops, options, callback) {
+ this.s.mongos.remove(ns, ops, options, callback);
+}
+
+// IsConnected
+Mongos.prototype.isConnected = function() {
+ return this.s.mongos.isConnected();
+}
+
+// Insert
+Mongos.prototype.cursor = function(ns, cmd, options) {
+ options.disconnectHandler = this.s.store;
+ return this.s.mongos.cursor(ns, cmd, options);
+}
+
+Mongos.prototype.setBSONParserType = function(type) {
+ return this.s.mongos.setBSONParserType(type);
+}
+
+Mongos.prototype.lastIsMaster = function() {
+ return this.s.mongos.lastIsMaster();
+}
+
+Mongos.prototype.close = function(forceClosed) {
+ this.s.mongos.destroy();
+ // We need to wash out all stored processes
+ if(forceClosed == true) {
+ this.s.storeOptions.force = forceClosed;
+ this.s.store.flush();
+ }
+}
+
+Mongos.prototype.auth = function() {
+ var args = Array.prototype.slice.call(arguments, 0);
+ this.s.mongos.auth.apply(this.s.mongos, args);
+}
+
+/**
+ * All raw connections
+ * @method
+ * @return {array}
+ */
+Mongos.prototype.connections = function() {
+ return this.s.mongos.connections();
+}
+
+/**
+ * A mongos connect event, used to verify that the connection is up and running
+ *
+ * @event Mongos#connect
+ * @type {Mongos}
+ */
+
+/**
+ * The mongos high availability event
+ *
+ * @event Mongos#ha
+ * @type {function}
+ * @param {string} type The stage in the high availability event (start|end)
+ * @param {boolean} data.norepeat This is a repeating high availability process or a single execution only
+ * @param {number} data.id The id for this high availability request
+ * @param {object} data.state An object containing the information about the current replicaset
+ */
+
+/**
+ * A server member left the mongos set
+ *
+ * @event Mongos#left
+ * @type {function}
+ * @param {string} type The type of member that left (primary|secondary|arbiter)
+ * @param {Server} server The server object that left
+ */
+
+/**
+ * A server member joined the mongos set
+ *
+ * @event Mongos#joined
+ * @type {function}
+ * @param {string} type The type of member that joined (primary|secondary|arbiter)
+ * @param {Server} server The server object that joined
+ */
+
+/**
+ * Mongos fullsetup event, emitted when all proxies in the topology have been connected to.
+ *
+ * @event Mongos#fullsetup
+ * @type {Mongos}
+ */
+
+/**
+ * Mongos open event, emitted when mongos can start processing commands.
+ *
+ * @event Mongos#open
+ * @type {Mongos}
+ */
+
+/**
+ * Mongos close event
+ *
+ * @event Mongos#close
+ * @type {object}
+ */
+
+/**
+ * Mongos error event, emitted if there is an error listener.
+ *
+ * @event Mongos#error
+ * @type {MongoError}
+ */
+
+/**
+ * Mongos timeout event
+ *
+ * @event Mongos#timeout
+ * @type {object}
+ */
+
+/**
+ * Mongos parseError event
+ *
+ * @event Mongos#parseError
+ * @type {object}
+ */
+
+module.exports = Mongos;
diff --git a/server/node_modules/mongodb/lib/read_preference.js b/server/node_modules/mongodb/lib/read_preference.js
new file mode 100755
index 00000000..73b253ae
--- /dev/null
+++ b/server/node_modules/mongodb/lib/read_preference.js
@@ -0,0 +1,104 @@
+"use strict";
+
+/**
+ * @fileOverview The **ReadPreference** class is a class that represents a MongoDB ReadPreference and is
+ * used to construct connections.
+ *
+ * @example
+ * var Db = require('mongodb').Db,
+ * ReplSet = require('mongodb').ReplSet,
+ * Server = require('mongodb').Server,
+ * ReadPreference = require('mongodb').ReadPreference,
+ * test = require('assert');
+ * // Connect using ReplSet
+ * var server = new Server('localhost', 27017);
+ * var db = new Db('test', new ReplSet([server]));
+ * db.open(function(err, db) {
+ * test.equal(null, err);
+ * // Perform a read
+ * var cursor = db.collection('t').find({});
+ * cursor.setReadPreference(ReadPreference.PRIMARY);
+ * cursor.toArray(function(err, docs) {
+ * test.equal(null, err);
+ * db.close();
+ * });
+ * });
+ */
+
+/**
+ * Creates a new ReadPreference instance
+ *
+ * Read Preferences
+ * - **ReadPreference.PRIMARY**, Read from primary only. All operations produce an error (throw an exception where applicable) if primary is unavailable. Cannot be combined with tags (This is the default.).
+ * - **ReadPreference.PRIMARY_PREFERRED**, Read from primary if available, otherwise a secondary.
+ * - **ReadPreference.SECONDARY**, Read from secondary if available, otherwise error.
+ * - **ReadPreference.SECONDARY_PREFERRED**, Read from a secondary if available, otherwise read from the primary.
+ * - **ReadPreference.NEAREST**, All modes read from among the nearest candidates, but unlike other modes, NEAREST will include both the primary and all secondaries in the random selection.
+ *
+ * @class
+ * @param {string} mode The ReadPreference mode as listed above.
+ * @param {object} tags An object representing read preference tags.
+ * @property {string} mode The ReadPreference mode.
+ * @property {object} tags The ReadPreference tags.
+ * @return {ReadPreference} a ReadPreference instance.
+ */
+var ReadPreference = function(mode, tags) {
+ if(!(this instanceof ReadPreference))
+ return new ReadPreference(mode, tags);
+ this._type = 'ReadPreference';
+ this.mode = mode;
+ this.tags = tags;
+}
+
+/**
+ * Validate if a mode is legal
+ *
+ * @method
+ * @param {string} mode The string representing the read preference mode.
+ * @return {boolean}
+ */
+ReadPreference.isValid = function(_mode) {
+ return (_mode == ReadPreference.PRIMARY || _mode == ReadPreference.PRIMARY_PREFERRED
+ || _mode == ReadPreference.SECONDARY || _mode == ReadPreference.SECONDARY_PREFERRED
+ || _mode == ReadPreference.NEAREST
+ || _mode == true || _mode == false || _mode == null);
+}
+
+/**
+ * Validate if a mode is legal
+ *
+ * @method
+ * @param {string} mode The string representing the read preference mode.
+ * @return {boolean}
+ */
+ReadPreference.prototype.isValid = function(mode) {
+ var _mode = typeof mode == 'string' ? mode : this.mode;
+ return ReadPreference.isValid(_mode);
+}
+
+/**
+ * @ignore
+ */
+ReadPreference.prototype.toObject = function() {
+ var object = {mode:this.mode};
+
+ if(this.tags != null) {
+ object['tags'] = this.tags;
+ }
+
+ return object;
+}
+
+/**
+ * @ignore
+ */
+ReadPreference.PRIMARY = 'primary';
+ReadPreference.PRIMARY_PREFERRED = 'primaryPreferred';
+ReadPreference.SECONDARY = 'secondary';
+ReadPreference.SECONDARY_PREFERRED = 'secondaryPreferred';
+ReadPreference.NEAREST = 'nearest'
+
+/**
+ * @ignore
+ */
+module.exports = ReadPreference;
\ No newline at end of file
diff --git a/server/node_modules/mongodb/lib/replset.js b/server/node_modules/mongodb/lib/replset.js
new file mode 100755
index 00000000..caab621d
--- /dev/null
+++ b/server/node_modules/mongodb/lib/replset.js
@@ -0,0 +1,527 @@
+"use strict";
+
+var EventEmitter = require('events').EventEmitter
+ , inherits = require('util').inherits
+ , f = require('util').format
+ , Server = require('./server')
+ , Mongos = require('./mongos')
+ , Cursor = require('./cursor')
+ , ReadPreference = require('./read_preference')
+ , MongoCR = require('mongodb-core').MongoCR
+ , MongoError = require('mongodb-core').MongoError
+ , ServerCapabilities = require('./topology_base').ServerCapabilities
+ , Store = require('./topology_base').Store
+ , CServer = require('mongodb-core').Server
+ , CReplSet = require('mongodb-core').ReplSet
+ , CoreReadPreference = require('mongodb-core').ReadPreference
+ , shallowClone = require('./utils').shallowClone;
+
+/**
+ * @fileOverview The **ReplSet** class is a class that represents a Replicaset topology and is
+ * used to construct connections.
+ *
+ * **ReplSet Should not be used, use MongoClient.connect**
+ * @example
+ * var Db = require('mongodb').Db,
+ * ReplSet = require('mongodb').ReplSet,
+ * Server = require('mongodb').Server,
+ * test = require('assert');
+ * // Connect using ReplSet
+ * var server = new Server('localhost', 27017);
+ * var db = new Db('test', new ReplSet([server]));
+ * db.open(function(err, db) {
+ * // Get an additional db
+ * db.close();
+ * });
+ */
+
+/**
+ * Creates a new ReplSet instance
+ * @class
+ * @deprecated
+ * @param {Server[]} servers A seedlist of servers participating in the replicaset.
+ * @param {object} [options=null] Optional settings.
+ * @param {booelan} [options.ha=true] Turn on high availability monitoring.
+ * @param {number} [options.haInterval=5000] Time between each replicaset status check.
+ * @param {string} options.replicaSet The name of the replicaset to connect to.
+ * @param {number} [options.secondaryAcceptableLatencyMS=15] Sets the range of servers to pick when using NEAREST (lowest ping ms + the latency fence, ex: range of 1 to (1 + 15) ms)
+ * @param {boolean} [options.connectWithNoPrimary=false] Sets if the driver should connect even if no primary is available
+ * @param {number} [options.poolSize=5] Number of connections in the connection pool for each server instance, set to 5 as default for legacy reasons.
+ * @param {boolean} [options.ssl=false] Use ssl connection (needs to have a mongod server with ssl support)
+ * @param {object} [options.sslValidate=true] Validate mongod server certificate against ca (needs to have a mongod server with ssl support, 2.4 or higher)
+ * @param {array} [options.sslCA=null] Array of valid certificates either as Buffers or Strings (needs to have a mongod server with ssl support, 2.4 or higher)
+ * @param {(Buffer|string)} [options.sslCert=null] String or buffer containing the certificate we wish to present (needs to have a mongod server with ssl support, 2.4 or higher)
+ * @param {(Buffer|string)} [options.sslKey=null] String or buffer containing the certificate private key we wish to present (needs to have a mongod server with ssl support, 2.4 or higher)
+ * @param {(Buffer|string)} [options.sslPass=null] String or buffer containing the certificate password (needs to have a mongod server with ssl support, 2.4 or higher)
+ * @param {object} [options.socketOptions=null] Socket options
+ * @param {boolean} [options.socketOptions.noDelay=true] TCP Socket NoDelay option.
+ * @param {number} [options.socketOptions.keepAlive=0] TCP KeepAlive on the socket with a X ms delay before start.
+ * @param {number} [options.socketOptions.connectTimeoutMS=0] TCP Connection timeout setting
+ * @param {number} [options.socketOptions.socketTimeoutMS=0] TCP Socket timeout setting
+ * @fires ReplSet#connect
+ * @fires ReplSet#ha
+ * @fires ReplSet#joined
+ * @fires ReplSet#left
+ * @fires ReplSet#fullsetup
+ * @fires ReplSet#open
+ * @fires ReplSet#close
+ * @fires ReplSet#error
+ * @fires ReplSet#timeout
+ * @fires ReplSet#parseError
+ * @return {ReplSet} a ReplSet instance.
+ */
+var ReplSet = function(servers, options) {
+ if(!(this instanceof ReplSet)) return new ReplSet(servers, options);
+ options = options || {};
+ var self = this;
+
+ // Ensure all the instances are Server
+ for(var i = 0; i < servers.length; i++) {
+ if(!(servers[i] instanceof Server)) {
+ throw new MongoError("all seed list instances must be of the Server type");
+ }
+ }
+
+ // Store option defaults
+ var storeOptions = {
+ force: false
+ , bufferMaxEntries: -1
+ }
+
+ // Shared global store
+ var store = options.store || new Store(self, storeOptions);
+
+ // Set up event emitter
+ EventEmitter.call(this);
+
+ // Debug tag
+ var tag = options.tag;
+
+ // Build seed list
+ var seedlist = servers.map(function(x) {
+ return {host: x.host, port: x.port}
+ });
+
+ // Final options
+ var finalOptions = shallowClone(options);
+
+ // Default values
+ finalOptions.size = typeof options.poolSize == 'number' ? options.poolSize : 5;
+ finalOptions.reconnect = typeof options.auto_reconnect == 'boolean' ? options.auto_reconnect : true;
+ finalOptions.emitError = typeof options.emitError == 'boolean' ? options.emitError : true;
+ finalOptions.cursorFactory = Cursor;
+
+ // Add the store
+ finalOptions.disconnectHandler = store;
+
+ // Socket options passed down
+ if(options.socketOptions) {
+ if(options.socketOptions.connectTimeoutMS) {
+ this.connectTimeoutMS = options.socketOptions.connectTimeoutMS;
+ finalOptions.connectionTimeout = options.socketOptions.connectTimeoutMS;
+ }
+
+ if(options.socketOptions.socketTimeoutMS) {
+ finalOptions.socketTimeout = options.socketOptions.socketTimeoutMS;
+ }
+ }
+
+ // Get the name
+ var replicaSet = options.replicaSet || options.rs_name;
+
+ // Set up options
+ finalOptions.setName = replicaSet;
+
+ // Are we running in debug mode
+ var debug = typeof options.debug == 'boolean' ? options.debug : false;
+ if(debug) {
+ finalOptions.debug = debug;
+ }
+
+ // Map keep alive setting
+ if(options.socketOptions && typeof options.socketOptions.keepAlive == 'number') {
+ finalOptions.keepAlive = true;
+ if(typeof options.socketOptions.keepAlive == 'number') {
+ finalOptions.keepAliveInitialDelay = options.socketOptions.keepAlive;
+ }
+ }
+
+ // Connection timeout
+ if(options.socketOptions && typeof options.socketOptions.connectionTimeout == 'number') {
+ finalOptions.connectionTimeout = options.socketOptions.connectionTimeout;
+ }
+
+ // Socket timeout
+ if(options.socketOptions && typeof options.socketOptions.socketTimeout == 'number') {
+ finalOptions.socketTimeout = options.socketOptions.socketTimeout;
+ }
+
+ // noDelay
+ if(options.socketOptions && typeof options.socketOptions.noDelay == 'boolean') {
+ finalOptions.noDelay = options.socketOptions.noDelay;
+ }
+
+ if(typeof options.secondaryAcceptableLatencyMS == 'number') {
+ finalOptions.acceptableLatency = options.secondaryAcceptableLatencyMS;
+ }
+
+ if(options.connectWithNoPrimary == true) {
+ finalOptions.secondaryOnlyConnectionAllowed = true;
+ }
+
+ // Add the non connection store
+ finalOptions.disconnectHandler = store;
+
+ // Translate the options
+ if(options.sslCA) finalOptions.ca = options.sslCA;
+ if(typeof options.sslValidate == 'boolean') finalOptions.rejectUnauthorized = options.sslValidate;
+ if(options.sslKey) finalOptions.key = options.sslKey;
+ if(options.sslCert) finalOptions.cert = options.sslCert;
+ if(options.sslPass) finalOptions.passphrase = options.sslPass;
+
+ // Create the ReplSet
+ var replset = new CReplSet(seedlist, finalOptions)
+ // Server capabilities
+ var sCapabilities = null;
+ // Add auth prbufferMaxEntriesoviders
+ replset.addAuthProvider('mongocr', new MongoCR());
+
+ // Listen to reconnect event
+ replset.on('reconnect', function() {
+ self.emit('reconnect');
+ store.execute();
+ });
+
+ // Internal state
+ this.s = {
+ // Replicaset
+ replset: replset
+ // Server capabilities
+ , sCapabilities: null
+ // Debug tag
+ , tag: options.tag
+ // Store options
+ , storeOptions: storeOptions
+ // Cloned options
+ , clonedOptions: finalOptions
+ // Store
+ , store: store
+ // Options
+ , options: options
+ }
+
+ // Debug
+ if(debug) {
+ // Last ismaster
+ Object.defineProperty(this, 'replset', {
+ enumerable:true, get: function() { return replset; }
+ });
+ }
+
+ // Last ismaster
+ Object.defineProperty(this, 'isMasterDoc', {
+ enumerable:true, get: function() { return replset.lastIsMaster(); }
+ });
+
+ // BSON property
+ Object.defineProperty(this, 'bson', {
+ enumerable: true, get: function() {
+ return replset.bson;
+ }
+ });
+
+ Object.defineProperty(this, 'haInterval', {
+ enumerable:true, get: function() { return replset.haInterval; }
+ });
+}
+
+/**
+ * @ignore
+ */
+inherits(ReplSet, EventEmitter);
+
+// Ensure the right read Preference object
+var translateReadPreference = function(options) {
+ if(typeof options.readPreference == 'string') {
+ options.readPreference = new CoreReadPreference(options.readPreference);
+ } else if(options.readPreference instanceof ReadPreference) {
+ options.readPreference = new CoreReadPreference(options.readPreference.mode
+ , options.readPreference.tags);
+ }
+
+ return options;
+}
+
+ReplSet.prototype.parserType = function() {
+ return this.s.replset.parserType();
+}
+
+// Connect method
+ReplSet.prototype.connect = function(db, _options, callback) {
+ var self = this;
+ if('function' === typeof _options) callback = _options, _options = {};
+ if(_options == null) _options = {};
+ if(!('function' === typeof callback)) callback = null;
+ self.s.options = _options;
+
+ // Update bufferMaxEntries
+ self.s.storeOptions.bufferMaxEntries = db.bufferMaxEntries;
+
+ // Actual handler
+ var errorHandler = function(event) {
+ return function(err) {
+ if(event != 'error') {
+ self.emit(event, err);
+ }
+ }
+ }
+
+ // Connect handler
+ var connectHandler = function() {
+ // Clear out all the current handlers left over
+ ["timeout", "error", "close"].forEach(function(e) {
+ self.s.replset.removeAllListeners(e);
+ });
+
+ // Set up listeners
+ self.s.replset.once('timeout', errorHandler('timeout'));
+ self.s.replset.once('error', errorHandler('error'));
+ self.s.replset.once('close', errorHandler('close'));
+
+ // relay the event
+ var relay = function(event) {
+ return function(t, server) {
+ self.emit(event, t, server);
+ }
+ }
+
+ // Replset events relay
+ var replsetRelay = function(event) {
+ return function(t, server) {
+ self.emit(event, t, server.lastIsMaster(), server);
+ }
+ }
+
+ // Relay ha
+ var relayHa = function(t, state) {
+ self.emit('ha', t, state);
+
+ if(t == 'start') {
+ self.emit('ha_connect', t, state);
+ } else if(t == 'end') {
+ self.emit('ha_ismaster', t, state);
+ }
+ }
+
+ // Set up serverConfig listeners
+ self.s.replset.on('joined', replsetRelay('joined'));
+ self.s.replset.on('left', relay('left'));
+ self.s.replset.on('ping', relay('ping'));
+ self.s.replset.on('ha', relayHa);
+
+ self.s.replset.on('fullsetup', function(topology) {
+ self.emit('fullsetup', null, self);
+ });
+
+ self.s.replset.on('all', function(topology) {
+ self.emit('all', null, self);
+ });
+
+ // Emit open event
+ self.emit('open', null, self);
+
+ // Return correctly
+ try {
+ callback(null, self);
+ } catch(err) {
+ process.nextTick(function() { throw err; })
+ }
+ }
+
+ // Error handler
+ var connectErrorHandler = function(event) {
+ return function(err) {
+ ['timeout', 'error', 'close'].forEach(function(e) {
+ self.s.replset.removeListener(e, connectErrorHandler);
+ });
+
+ self.s.replset.removeListener('connect', connectErrorHandler);
+ // Destroy the replset
+ self.s.replset.destroy();
+
+ // Try to callback
+ try {
+ callback(err);
+ } catch(err) {
+ if(!self.s.replset.isConnected())
+ process.nextTick(function() { throw err; })
+ }
+ }
+ }
+
+ // Set up listeners
+ self.s.replset.once('timeout', connectErrorHandler('timeout'));
+ self.s.replset.once('error', connectErrorHandler('error'));
+ self.s.replset.once('close', connectErrorHandler('close'));
+ self.s.replset.once('connect', connectHandler);
+
+ // Start connection
+ self.s.replset.connect(_options);
+}
+
+// Server capabilities
+ReplSet.prototype.capabilities = function() {
+ if(this.s.sCapabilities) return this.s.sCapabilities;
+ this.s.sCapabilities = new ServerCapabilities(this.s.replset.lastIsMaster());
+ return this.s.sCapabilities;
+}
+
+// Command
+ReplSet.prototype.command = function(ns, cmd, options, callback) {
+ options = translateReadPreference(options);
+ this.s.replset.command(ns, cmd, options, callback);
+}
+
+// Insert
+ReplSet.prototype.insert = function(ns, ops, options, callback) {
+ this.s.replset.insert(ns, ops, options, callback);
+}
+
+// Update
+ReplSet.prototype.update = function(ns, ops, options, callback) {
+ this.s.replset.update(ns, ops, options, callback);
+}
+
+// Remove
+ReplSet.prototype.remove = function(ns, ops, options, callback) {
+ this.s.replset.remove(ns, ops, options, callback);
+}
+
+// IsConnected
+ReplSet.prototype.isConnected = function() {
+ return this.s.replset.isConnected();
+}
+
+ReplSet.prototype.setBSONParserType = function(type) {
+ return this.s.replset.setBSONParserType(type);
+}
+
+// Insert
+ReplSet.prototype.cursor = function(ns, cmd, options) {
+ options = translateReadPreference(options);
+ options.disconnectHandler = this.s.store;
+ return this.s.replset.cursor(ns, cmd, options);
+}
+
+ReplSet.prototype.lastIsMaster = function() {
+ return this.s.replset.lastIsMaster();
+}
+
+ReplSet.prototype.close = function(forceClosed) {
+ var self = this;
+ this.s.replset.destroy();
+ // We need to wash out all stored processes
+ if(forceClosed == true) {
+ this.s.storeOptions.force = forceClosed;
+ this.s.store.flush();
+ }
+
+ var events = ['timeout', 'error', 'close', 'joined', 'left'];
+ events.forEach(function(e) {
+ self.removeAllListeners(e);
+ });
+}
+
+ReplSet.prototype.auth = function() {
+ var args = Array.prototype.slice.call(arguments, 0);
+ this.s.replset.auth.apply(this.s.replset, args);
+}
+
+/**
+ * All raw connections
+ * @method
+ * @return {array}
+ */
+ReplSet.prototype.connections = function() {
+ return this.s.replset.connections();
+}
+
+/**
+ * A replset connect event, used to verify that the connection is up and running
+ *
+ * @event ReplSet#connect
+ * @type {ReplSet}
+ */
+
+/**
+ * The replset high availability event
+ *
+ * @event ReplSet#ha
+ * @type {function}
+ * @param {string} type The stage in the high availability event (start|end)
+ * @param {boolean} data.norepeat This is a repeating high availability process or a single execution only
+ * @param {number} data.id The id for this high availability request
+ * @param {object} data.state An object containing the information about the current replicaset
+ */
+
+/**
+ * A server member left the replicaset
+ *
+ * @event ReplSet#left
+ * @type {function}
+ * @param {string} type The type of member that left (primary|secondary|arbiter)
+ * @param {Server} server The server object that left
+ */
+
+/**
+ * A server member joined the replicaset
+ *
+ * @event ReplSet#joined
+ * @type {function}
+ * @param {string} type The type of member that joined (primary|secondary|arbiter)
+ * @param {Server} server The server object that joined
+ */
+
+/**
+ * ReplSet open event, emitted when replicaset can start processing commands.
+ *
+ * @event ReplSet#open
+ * @type {Replset}
+ */
+
+/**
+ * ReplSet fullsetup event, emitted when all servers in the topology have been connected to.
+ *
+ * @event ReplSet#fullsetup
+ * @type {Replset}
+ */
+
+/**
+ * ReplSet close event
+ *
+ * @event ReplSet#close
+ * @type {object}
+ */
+
+/**
+ * ReplSet error event, emitted if there is an error listener.
+ *
+ * @event ReplSet#error
+ * @type {MongoError}
+ */
+
+/**
+ * ReplSet timeout event
+ *
+ * @event ReplSet#timeout
+ * @type {object}
+ */
+
+/**
+ * ReplSet parseError event
+ *
+ * @event ReplSet#parseError
+ * @type {object}
+ */
+
+module.exports = ReplSet;
\ No newline at end of file
diff --git a/server/node_modules/mongodb/lib/server.js b/server/node_modules/mongodb/lib/server.js
new file mode 100755
index 00000000..0a5df683
--- /dev/null
+++ b/server/node_modules/mongodb/lib/server.js
@@ -0,0 +1,408 @@
+"use strict";
+
+var EventEmitter = require('events').EventEmitter
+ , inherits = require('util').inherits
+ , CServer = require('mongodb-core').Server
+ , Cursor = require('./cursor')
+ , f = require('util').format
+ , ServerCapabilities = require('./topology_base').ServerCapabilities
+ , Store = require('./topology_base').Store
+ , MongoError = require('mongodb-core').MongoError
+ , shallowClone = require('./utils').shallowClone;
+
+/**
+ * @fileOverview The **Server** class is a class that represents a single server topology and is
+ * used to construct connections.
+ *
+ * **Server Should not be used, use MongoClient.connect**
+ * @example
+ * var Db = require('mongodb').Db,
+ * Server = require('mongodb').Server,
+ * test = require('assert');
+ * // Connect using single Server
+ * var db = new Db('test', new Server('localhost', 27017););
+ * db.open(function(err, db) {
+ * // Get an additional db
+ * db.close();
+ * });
+ */
+
+/**
+ * Creates a new Server instance
+ * @class
+ * @deprecated
+ * @param {string} host The host for the server, can be either an IP4, IP6 or domain socket style host.
+ * @param {number} [port] The server port if IP4.
+ * @param {object} [options=null] Optional settings.
+ * @param {number} [options.poolSize=5] Number of connections in the connection pool for each server instance, set to 5 as default for legacy reasons.
+ * @param {boolean} [options.ssl=false] Use ssl connection (needs to have a mongod server with ssl support)
+ * @param {object} [options.sslValidate=true] Validate mongod server certificate against ca (needs to have a mongod server with ssl support, 2.4 or higher)
+ * @param {array} [options.sslCA=null] Array of valid certificates either as Buffers or Strings (needs to have a mongod server with ssl support, 2.4 or higher)
+ * @param {(Buffer|string)} [options.sslCert=null] String or buffer containing the certificate we wish to present (needs to have a mongod server with ssl support, 2.4 or higher)
+ * @param {(Buffer|string)} [options.sslKey=null] String or buffer containing the certificate private key we wish to present (needs to have a mongod server with ssl support, 2.4 or higher)
+ * @param {(Buffer|string)} [options.sslPass=null] String or buffer containing the certificate password (needs to have a mongod server with ssl support, 2.4 or higher)
+ * @param {object} [options.socketOptions=null] Socket options
+ * @param {boolean} [options.socketOptions.autoReconnect=false] Reconnect on error.
+ * @param {boolean} [options.socketOptions.noDelay=true] TCP Socket NoDelay option.
+ * @param {number} [options.socketOptions.keepAlive=0] TCP KeepAlive on the socket with a X ms delay before start.
+ * @param {number} [options.socketOptions.connectTimeoutMS=0] TCP Connection timeout setting
+ * @param {number} [options.socketOptions.socketTimeoutMS=0] TCP Socket timeout setting
+ * @param {number} [options.reconnectTries=30] Server attempt to reconnect #times
+ * @param {number} [options.reconnectInterval=1000] Server will wait # milliseconds between retries
+ * @fires Server#connect
+ * @fires Server#close
+ * @fires Server#error
+ * @fires Server#timeout
+ * @fires Server#parseError
+ * @fires Server#reconnect
+ * @return {Server} a Server instance.
+ */
+var Server = function(host, port, options) {
+ options = options || {};
+ if(!(this instanceof Server)) return new Server(host, port, options);
+ EventEmitter.call(this);
+ var self = this;
+
+ // Store option defaults
+ var storeOptions = {
+ force: false
+ , bufferMaxEntries: -1
+ }
+
+ // Shared global store
+ var store = options.store || new Store(self, storeOptions);
+
+ // Detect if we have a socket connection
+ if(host.indexOf('\/') != -1) {
+ if(port != null && typeof port == 'object') {
+ options = port;
+ port = null;
+ }
+ } else if(port == null) {
+ throw new MongoError('port must be specified');
+ }
+
+ // Clone options
+ var clonedOptions = shallowClone(options);
+ clonedOptions.host = host;
+ clonedOptions.port = port;
+
+ // Reconnect
+ var reconnect = typeof options.auto_reconnect == 'boolean' ? options.auto_reconnect : true;
+ reconnect = typeof options.autoReconnect == 'boolean' ? options.autoReconnect : reconnect;
+ var emitError = typeof options.emitError == 'boolean' ? options.emitError : true;
+ var poolSize = typeof options.poolSize == 'number' ? options.poolSize : 5;
+
+ // Socket options passed down
+ if(options.socketOptions) {
+ if(options.socketOptions.connectTimeoutMS) {
+ this.connectTimeoutMS = options.socketOptions.connectTimeoutMS;
+ clonedOptions.connectionTimeout = options.socketOptions.connectTimeoutMS;
+ }
+
+ if(options.socketOptions.socketTimeoutMS) {
+ clonedOptions.socketTimeout = options.socketOptions.socketTimeoutMS;
+ }
+
+ if(typeof options.socketOptions.keepAlive == 'number') {
+ clonedOptions.keepAliveInitialDelay = options.socketOptions.keepAlive;
+ clonedOptions.keepAlive = true;
+ }
+
+ if(typeof options.socketOptions.noDelay == 'boolean') {
+ clonedOptions.noDelay = options.socketOptions.noDelay;
+ }
+ }
+
+ // Add the cursor factory function
+ clonedOptions.cursorFactory = Cursor;
+ clonedOptions.reconnect = reconnect;
+ clonedOptions.emitError = emitError;
+ clonedOptions.size = poolSize;
+
+ // Translate the options
+ if(clonedOptions.sslCA) clonedOptions.ca = clonedOptions.sslCA;
+ if(typeof clonedOptions.sslValidate == 'boolean') clonedOptions.rejectUnauthorized = clonedOptions.sslValidate;
+ if(clonedOptions.sslKey) clonedOptions.key = clonedOptions.sslKey;
+ if(clonedOptions.sslCert) clonedOptions.cert = clonedOptions.sslCert;
+ if(clonedOptions.sslPass) clonedOptions.passphrase = clonedOptions.sslPass;
+
+ // Add the non connection store
+ clonedOptions.disconnectHandler = store;
+
+ // Create an instance of a server instance from mongodb-core
+ var server = new CServer(clonedOptions);
+ // Server capabilities
+ var sCapabilities = null;
+
+ // Define the internal properties
+ this.s = {
+ // Create an instance of a server instance from mongodb-core
+ server: server
+ // Server capabilities
+ , sCapabilities: null
+ // Cloned options
+ , clonedOptions: clonedOptions
+ // Reconnect
+ , reconnect: reconnect
+ // Emit error
+ , emitError: emitError
+ // Pool size
+ , poolSize: poolSize
+ // Store Options
+ , storeOptions: storeOptions
+ // Store
+ , store: store
+ // Host
+ , host: host
+ // Port
+ , port: port
+ // Options
+ , options: options
+ }
+
+ // BSON property
+ Object.defineProperty(this, 'bson', {
+ enumerable: true, get: function() {
+ return self.s.server.bson;
+ }
+ });
+
+ // Last ismaster
+ Object.defineProperty(this, 'isMasterDoc', {
+ enumerable:true, get: function() {
+ return self.s.server.lastIsMaster();
+ }
+ });
+
+ // Last ismaster
+ Object.defineProperty(this, 'poolSize', {
+ enumerable:true, get: function() { return self.s.server.connections().length; }
+ });
+
+ Object.defineProperty(this, 'autoReconnect', {
+ enumerable:true, get: function() { return self.s.reconnect; }
+ });
+
+ Object.defineProperty(this, 'host', {
+ enumerable:true, get: function() { return self.s.host; }
+ });
+
+ Object.defineProperty(this, 'port', {
+ enumerable:true, get: function() { return self.s.port; }
+ });
+}
+
+inherits(Server, EventEmitter);
+
+Server.prototype.parserType = function() {
+ return this.s.server.parserType();
+}
+
+// Connect
+Server.prototype.connect = function(db, _options, callback) {
+ var self = this;
+ if('function' === typeof _options) callback = _options, _options = {};
+ if(_options == null) _options = {};
+ if(!('function' === typeof callback)) callback = null;
+ self.s.options = _options;
+
+ // Update bufferMaxEntries
+ self.s.storeOptions.bufferMaxEntries = db.bufferMaxEntries;
+
+ // Error handler
+ var connectErrorHandler = function(event) {
+ return function(err) {
+ // Remove all event handlers
+ var events = ['timeout', 'error', 'close'];
+ events.forEach(function(e) {
+ self.s.server.removeListener(e, connectHandlers[e]);
+ });
+
+ self.s.server.removeListener('connect', connectErrorHandler);
+
+ // Try to callback
+ try {
+ callback(err);
+ } catch(err) {
+ process.nextTick(function() { throw err; })
+ }
+ }
+ }
+
+ // Actual handler
+ var errorHandler = function(event) {
+ return function(err) {
+ if(event != 'error') {
+ self.emit(event, err);
+ }
+ }
+ }
+
+ // Error handler
+ var reconnectHandler = function(err) {
+ self.emit('reconnect', self);
+ self.s.store.execute();
+ }
+
+ // Destroy called on topology, perform cleanup
+ var destroyHandler = function() {
+ self.s.store.flush();
+ }
+
+ // Connect handler
+ var connectHandler = function() {
+ // Clear out all the current handlers left over
+ ["timeout", "error", "close"].forEach(function(e) {
+ self.s.server.removeAllListeners(e);
+ });
+
+ // Set up listeners
+ self.s.server.once('timeout', errorHandler('timeout'));
+ self.s.server.once('error', errorHandler('error'));
+ self.s.server.once('close', errorHandler('close'));
+ // Only called on destroy
+ self.s.server.once('destroy', destroyHandler);
+
+ // Emit open event
+ self.emit('open', null, self);
+
+ // Return correctly
+ try {
+ callback(null, self);
+ } catch(err) {
+ process.nextTick(function() { throw err; })
+ }
+ }
+
+ // Set up listeners
+ var connectHandlers = {
+ timeout: connectErrorHandler('timeout'),
+ error: connectErrorHandler('error'),
+ close: connectErrorHandler('close')
+ };
+
+ // Add the event handlers
+ self.s.server.once('timeout', connectHandlers.timeout);
+ self.s.server.once('error', connectHandlers.error);
+ self.s.server.once('close', connectHandlers.close);
+ self.s.server.once('connect', connectHandler);
+ // Reconnect server
+ self.s.server.on('reconnect', reconnectHandler);
+
+ // Start connection
+ self.s.server.connect(_options);
+}
+
+// Server capabilities
+Server.prototype.capabilities = function() {
+ if(this.s.sCapabilities) return this.s.sCapabilities;
+ this.s.sCapabilities = new ServerCapabilities(this.s.server.lastIsMaster());
+ return this.s.sCapabilities;
+}
+
+// Command
+Server.prototype.command = function(ns, cmd, options, callback) {
+ this.s.server.command(ns, cmd, options, callback);
+}
+
+// Insert
+Server.prototype.insert = function(ns, ops, options, callback) {
+ this.s.server.insert(ns, ops, options, callback);
+}
+
+// Update
+Server.prototype.update = function(ns, ops, options, callback) {
+ this.s.server.update(ns, ops, options, callback);
+}
+
+// Remove
+Server.prototype.remove = function(ns, ops, options, callback) {
+ this.s.server.remove(ns, ops, options, callback);
+}
+
+// IsConnected
+Server.prototype.isConnected = function() {
+ return this.s.server.isConnected();
+}
+
+// Insert
+Server.prototype.cursor = function(ns, cmd, options) {
+ options.disconnectHandler = this.s.store;
+ return this.s.server.cursor(ns, cmd, options);
+}
+
+Server.prototype.setBSONParserType = function(type) {
+ return this.s.server.setBSONParserType(type);
+}
+
+Server.prototype.lastIsMaster = function() {
+ return this.s.server.lastIsMaster();
+}
+
+Server.prototype.close = function(forceClosed) {
+ this.s.server.destroy();
+ // We need to wash out all stored processes
+ if(forceClosed == true) {
+ this.s.storeOptions.force = forceClosed;
+ this.s.store.flush();
+ }
+}
+
+Server.prototype.auth = function() {
+ var args = Array.prototype.slice.call(arguments, 0);
+ this.s.server.auth.apply(this.s.server, args);
+}
+
+/**
+ * All raw connections
+ * @method
+ * @return {array}
+ */
+Server.prototype.connections = function() {
+ return this.s.server.connections();
+}
+
+/**
+ * Server connect event
+ *
+ * @event Server#connect
+ * @type {object}
+ */
+
+/**
+ * Server close event
+ *
+ * @event Server#close
+ * @type {object}
+ */
+
+/**
+ * Server reconnect event
+ *
+ * @event Server#reconnect
+ * @type {object}
+ */
+
+/**
+ * Server error event
+ *
+ * @event Server#error
+ * @type {MongoError}
+ */
+
+/**
+ * Server timeout event
+ *
+ * @event Server#timeout
+ * @type {object}
+ */
+
+/**
+ * Server parseError event
+ *
+ * @event Server#parseError
+ * @type {object}
+ */
+
+module.exports = Server;
diff --git a/server/node_modules/mongodb/lib/topology_base.js b/server/node_modules/mongodb/lib/topology_base.js
new file mode 100755
index 00000000..460cd312
--- /dev/null
+++ b/server/node_modules/mongodb/lib/topology_base.js
@@ -0,0 +1,140 @@
+"use strict";
+
+var MongoError = require('mongodb-core').MongoError
+ , f = require('util').format;
+
+// The store of ops
+var Store = function(topology, storeOptions) {
+ var self = this;
+ var storedOps = [];
+ storeOptions = storeOptions || {force:false, bufferMaxEntries: -1}
+
+ // Internal state
+ this.s = {
+ storedOps: storedOps
+ , storeOptions: storeOptions
+ , topology: topology
+ }
+
+ Object.defineProperty(this, 'length', {
+ enumerable:true, get: function() { return self.s.storedOps.length; }
+ });
+}
+
+Store.prototype.add = function(opType, ns, ops, options, callback) {
+ if(this.s.storeOptions.force) return callback(new MongoError("db closed by application"));
+ if(this.s.storeOptions.bufferMaxEntries == 0) return callback(new MongoError(f("no connection available for operation and number of stored operation > %s", this.s.storeOptions.bufferMaxEntries)));
+ if(this.s.storeOptions.bufferMaxEntries > 0 && this.s.storedOps.length > this.s.storeOptions.bufferMaxEntries) {
+ while(this.s.storedOps.length > 0) {
+ var op = this.s.storedOps.shift();
+ op.c(new MongoError(f("no connection available for operation and number of stored operation > %s", this.s.storeOptions.bufferMaxEntries)));
+ }
+
+ return;
+ }
+
+ this.s.storedOps.push({t: opType, n: ns, o: ops, op: options, c: callback})
+}
+
+Store.prototype.addObjectAndMethod = function(opType, object, method, params, callback) {
+ if(this.s.storeOptions.force) return callback(new MongoError("db closed by application"));
+ if(this.s.storeOptions.bufferMaxEntries == 0) return callback(new MongoError(f("no connection available for operation and number of stored operation > %s", this.s.storeOptions.bufferMaxEntries)));
+ if(this.s.storeOptions.bufferMaxEntries > 0 && this.s.storedOps.length > this.s.storeOptions.bufferMaxEntries) {
+ while(this.s.storedOps.length > 0) {
+ var op = this.s.storedOps.shift();
+ op.c(new MongoError(f("no connection available for operation and number of stored operation > %s", this.s.storeOptions.bufferMaxEntries)));
+ }
+
+ return;
+ }
+
+ this.s.storedOps.push({t: opType, m: method, o: object, p: params, c: callback})
+}
+
+Store.prototype.flush = function() {
+ while(this.s.storedOps.length > 0) {
+ this.s.storedOps.shift().c(new MongoError(f("no connection available for operation")));
+ }
+}
+
+Store.prototype.execute = function() {
+ // Get current ops
+ var ops = this.s.storedOps;
+ // Reset the ops
+ this.s.storedOps = [];
+
+ // Execute all the stored ops
+ while(ops.length > 0) {
+ var op = ops.shift();
+
+ if(op.t == 'cursor') {
+ op.o[op.m].apply(op.o, op.p);
+ } else {
+ this.s.topology[op.t](op.n, op.o, op.op, op.c);
+ }
+ }
+}
+
+Store.prototype.all = function() {
+ return this.s.storedOps;
+}
+
+// Server capabilities
+var ServerCapabilities = function(ismaster) {
+ var setup_get_property = function(object, name, value) {
+ Object.defineProperty(object, name, {
+ enumerable: true
+ , get: function () { return value; }
+ });
+ }
+
+ // Capabilities
+ var aggregationCursor = false;
+ var writeCommands = false;
+ var textSearch = false;
+ var authCommands = false;
+ var listCollections = false;
+ var listIndexes = false;
+ var maxNumberOfDocsInBatch = ismaster.maxWriteBatchSize || 1000;
+
+ if(ismaster.minWireVersion >= 0) {
+ textSearch = true;
+ }
+
+ if(ismaster.maxWireVersion >= 1) {
+ aggregationCursor = true;
+ authCommands = true;
+ }
+
+ if(ismaster.maxWireVersion >= 2) {
+ writeCommands = true;
+ }
+
+ if(ismaster.maxWireVersion >= 3) {
+ listCollections = true;
+ listIndexes = true;
+ }
+
+ // If no min or max wire version set to 0
+ if(ismaster.minWireVersion == null) {
+ ismaster.minWireVersion = 0;
+ }
+
+ if(ismaster.maxWireVersion == null) {
+ ismaster.maxWireVersion = 0;
+ }
+
+ // Map up read only parameters
+ setup_get_property(this, "hasAggregationCursor", aggregationCursor);
+ setup_get_property(this, "hasWriteCommands", writeCommands);
+ setup_get_property(this, "hasTextSearch", textSearch);
+ setup_get_property(this, "hasAuthCommands", authCommands);
+ setup_get_property(this, "hasListCollectionsCommand", listCollections);
+ setup_get_property(this, "hasListIndexesCommand", listIndexes);
+ setup_get_property(this, "minWireVersion", ismaster.minWireVersion);
+ setup_get_property(this, "maxWireVersion", ismaster.maxWireVersion);
+ setup_get_property(this, "maxNumberOfDocsInBatch", maxNumberOfDocsInBatch);
+}
+
+exports.Store = Store;
+exports.ServerCapabilities = ServerCapabilities;
\ No newline at end of file
diff --git a/server/node_modules/mongodb/lib/url_parser.js b/server/node_modules/mongodb/lib/url_parser.js
new file mode 100755
index 00000000..c4f97192
--- /dev/null
+++ b/server/node_modules/mongodb/lib/url_parser.js
@@ -0,0 +1,281 @@
+"use strict";
+
+var ReadPreference = require('./read_preference');
+
+module.exports = function(url, options) {
+ // Ensure we have a default options object if none set
+ options = options || {};
+ // Variables
+ var connection_part = '';
+ var auth_part = '';
+ var query_string_part = '';
+ var dbName = 'admin';
+
+ // Must start with mongodb
+ if(url.indexOf("mongodb://") != 0)
+ throw Error("URL must be in the format mongodb://user:pass@host:port/dbname");
+ // If we have a ? mark cut the query elements off
+ if(url.indexOf("?") != -1) {
+ query_string_part = url.substr(url.indexOf("?") + 1);
+ connection_part = url.substring("mongodb://".length, url.indexOf("?"))
+ } else {
+ connection_part = url.substring("mongodb://".length);
+ }
+
+ // Check if we have auth params
+ if(connection_part.indexOf("@") != -1) {
+ auth_part = connection_part.split("@")[0];
+ connection_part = connection_part.split("@")[1];
+ }
+
+ // Check if the connection string has a db
+ if(connection_part.indexOf(".sock") != -1) {
+ if(connection_part.indexOf(".sock/") != -1) {
+ dbName = connection_part.split(".sock/")[1];
+ connection_part = connection_part.split("/", connection_part.indexOf(".sock") + ".sock".length);
+ }
+ } else if(connection_part.indexOf("/") != -1) {
+ dbName = connection_part.split("/")[1];
+ connection_part = connection_part.split("/")[0];
+ }
+
+ // Result object
+ var object = {};
+
+ // Pick apart the authentication part of the string
+ var authPart = auth_part || '';
+ var auth = authPart.split(':', 2);
+
+ // Decode the URI components
+ auth[0] = decodeURIComponent(auth[0]);
+ if(auth[1]){
+ auth[1] = decodeURIComponent(auth[1]);
+ }
+
+ // Add auth to final object if we have 2 elements
+ if(auth.length == 2) object.auth = {user: auth[0], password: auth[1]};
+
+ // Variables used for temporary storage
+ var hostPart;
+ var urlOptions;
+ var servers;
+ var serverOptions = {socketOptions: {}};
+ var dbOptions = {read_preference_tags: []};
+ var replSetServersOptions = {socketOptions: {}};
+ // Add server options to final object
+ object.server_options = serverOptions;
+ object.db_options = dbOptions;
+ object.rs_options = replSetServersOptions;
+ object.mongos_options = {};
+
+ // Let's check if we are using a domain socket
+ if(url.match(/\.sock/)) {
+ // Split out the socket part
+ var domainSocket = url.substring(
+ url.indexOf("mongodb://") + "mongodb://".length
+ , url.lastIndexOf(".sock") + ".sock".length);
+ // Clean out any auth stuff if any
+ if(domainSocket.indexOf("@") != -1) domainSocket = domainSocket.split("@")[1];
+ servers = [{domain_socket: domainSocket}];
+ } else {
+ // Split up the db
+ hostPart = connection_part;
+ // Parse all server results
+ servers = hostPart.split(',').map(function(h) {
+ var _host, _port, ipv6match;
+ //check if it matches [IPv6]:port, where the port number is optional
+ if ((ipv6match = /\[([^\]]+)\](?:\:(.+))?/.exec(h))) {
+ _host = ipv6match[1];
+ _port = parseInt(ipv6match[2], 10) || 27017;
+ } else {
+ //otherwise assume it's IPv4, or plain hostname
+ var hostPort = h.split(':', 2);
+ _host = hostPort[0] || 'localhost';
+ _port = hostPort[1] != null ? parseInt(hostPort[1], 10) : 27017;
+ // Check for localhost?safe=true style case
+ if(_host.indexOf("?") != -1) _host = _host.split(/\?/)[0];
+ }
+ // Return the mapped object
+ return {host: _host, port: _port};
+ });
+ }
+
+ // Get the db name
+ object.dbName = dbName || 'admin';
+ // Split up all the options
+ urlOptions = (query_string_part || '').split(/[&;]/);
+ // Ugh, we have to figure out which options go to which constructor manually.
+ urlOptions.forEach(function(opt) {
+ if(!opt) return;
+ var splitOpt = opt.split('='), name = splitOpt[0], value = splitOpt[1];
+ // Options implementations
+ switch(name) {
+ case 'slaveOk':
+ case 'slave_ok':
+ serverOptions.slave_ok = (value == 'true');
+ dbOptions.slaveOk = (value == 'true');
+ break;
+ case 'maxPoolSize':
+ case 'poolSize':
+ serverOptions.poolSize = parseInt(value, 10);
+ replSetServersOptions.poolSize = parseInt(value, 10);
+ break;
+ case 'autoReconnect':
+ case 'auto_reconnect':
+ serverOptions.auto_reconnect = (value == 'true');
+ break;
+ case 'minPoolSize':
+ throw new Error("minPoolSize not supported");
+ case 'maxIdleTimeMS':
+ throw new Error("maxIdleTimeMS not supported");
+ case 'waitQueueMultiple':
+ throw new Error("waitQueueMultiple not supported");
+ case 'waitQueueTimeoutMS':
+ throw new Error("waitQueueTimeoutMS not supported");
+ case 'uuidRepresentation':
+ throw new Error("uuidRepresentation not supported");
+ case 'ssl':
+ if(value == 'prefer') {
+ serverOptions.ssl = value;
+ replSetServersOptions.ssl = value;
+ break;
+ }
+ serverOptions.ssl = (value == 'true');
+ replSetServersOptions.ssl = (value == 'true');
+ break;
+ case 'replicaSet':
+ case 'rs_name':
+ replSetServersOptions.rs_name = value;
+ break;
+ case 'reconnectWait':
+ replSetServersOptions.reconnectWait = parseInt(value, 10);
+ break;
+ case 'retries':
+ replSetServersOptions.retries = parseInt(value, 10);
+ break;
+ case 'readSecondary':
+ case 'read_secondary':
+ replSetServersOptions.read_secondary = (value == 'true');
+ break;
+ case 'fsync':
+ dbOptions.fsync = (value == 'true');
+ break;
+ case 'journal':
+ dbOptions.j = (value == 'true');
+ break;
+ case 'safe':
+ dbOptions.safe = (value == 'true');
+ break;
+ case 'nativeParser':
+ case 'native_parser':
+ dbOptions.native_parser = (value == 'true');
+ break;
+ case 'connectTimeoutMS':
+ serverOptions.socketOptions.connectTimeoutMS = parseInt(value, 10);
+ replSetServersOptions.socketOptions.connectTimeoutMS = parseInt(value, 10);
+ break;
+ case 'socketTimeoutMS':
+ serverOptions.socketOptions.socketTimeoutMS = parseInt(value, 10);
+ replSetServersOptions.socketOptions.socketTimeoutMS = parseInt(value, 10);
+ break;
+ case 'w':
+ dbOptions.w = parseInt(value, 10);
+ if(isNaN(dbOptions.w)) dbOptions.w = value;
+ break;
+ case 'authSource':
+ dbOptions.authSource = value;
+ break;
+ case 'gssapiServiceName':
+ dbOptions.gssapiServiceName = value;
+ break;
+ case 'authMechanism':
+ if(value == 'GSSAPI') {
+ // If no password provided decode only the principal
+ if(object.auth == null) {
+ var urlDecodeAuthPart = decodeURIComponent(authPart);
+ if(urlDecodeAuthPart.indexOf("@") == -1) throw new Error("GSSAPI requires a provided principal");
+ object.auth = {user: urlDecodeAuthPart, password: null};
+ } else {
+ object.auth.user = decodeURIComponent(object.auth.user);
+ }
+ } else if(value == 'MONGODB-X509') {
+ object.auth = {user: decodeURIComponent(authPart)};
+ }
+
+ // Only support GSSAPI or MONGODB-CR for now
+ if(value != 'GSSAPI'
+ && value != 'MONGODB-X509'
+ && value != 'MONGODB-CR'
+ && value != 'SCRAM-SHA-1'
+ && value != 'PLAIN')
+ throw new Error("only GSSAPI, PLAIN, MONGODB-X509, SCRAM-SHA-1 or MONGODB-CR is supported by authMechanism");
+
+ // Authentication mechanism
+ dbOptions.authMechanism = value;
+ break;
+ case 'authMechanismProperties':
+ // Split up into key, value pairs
+ var values = value.split(',');
+ var o = {};
+ // For each value split into key, value
+ values.forEach(function(x) {
+ var v = x.split(':');
+ o[v[0]] = v[1];
+ });
+
+ // Set all authMechanismProperties
+ dbOptions.authMechanismProperties = o;
+ // Set the service name value
+ if(typeof o.SERVICE_NAME == 'string') dbOptions.gssapiServiceName = o.SERVICE_NAME;
+ break;
+ case 'wtimeoutMS':
+ dbOptions.wtimeout = parseInt(value, 10);
+ break;
+ case 'readPreference':
+ if(!ReadPreference.isValid(value)) throw new Error("readPreference must be either primary/primaryPreferred/secondary/secondaryPreferred/nearest");
+ dbOptions.read_preference = value;
+ break;
+ case 'readPreferenceTags':
+ // Decode the value
+ value = decodeURIComponent(value);
+ // Contains the tag object
+ var tagObject = {};
+ if(value == null || value == '') {
+ dbOptions.read_preference_tags.push(tagObject);
+ break;
+ }
+
+ // Split up the tags
+ var tags = value.split(/\,/);
+ for(var i = 0; i < tags.length; i++) {
+ var parts = tags[i].trim().split(/\:/);
+ tagObject[parts[0]] = parts[1];
+ }
+
+ // Set the preferences tags
+ dbOptions.read_preference_tags.push(tagObject);
+ break;
+ default:
+ break;
+ }
+ });
+
+ // No tags: should be null (not [])
+ if(dbOptions.read_preference_tags.length === 0) {
+ dbOptions.read_preference_tags = null;
+ }
+
+ // Validate if there are an invalid write concern combinations
+ if((dbOptions.w == -1 || dbOptions.w == 0) && (
+ dbOptions.journal == true
+ || dbOptions.fsync == true
+ || dbOptions.safe == true)) throw new Error("w set to -1 or 0 cannot be combined with safe/w/journal/fsync")
+
+ // If no read preference set it to primary
+ if(!dbOptions.read_preference) dbOptions.read_preference = 'primary';
+
+ // Add servers to result
+ object.servers = servers;
+ // Returned parsed object
+ return object;
+}
diff --git a/server/node_modules/mongodb/lib/utils.js b/server/node_modules/mongodb/lib/utils.js
new file mode 100755
index 00000000..e13c85c6
--- /dev/null
+++ b/server/node_modules/mongodb/lib/utils.js
@@ -0,0 +1,233 @@
+"use strict";
+
+var MongoError = require('mongodb-core').MongoError
+
+var shallowClone = function(obj) {
+ var copy = {};
+ for(var name in obj) copy[name] = obj[name];
+ return copy;
+}
+
+// Set simple property
+var getSingleProperty = function(obj, name, value) {
+ Object.defineProperty(obj, name, {
+ enumerable:true,
+ get: function() {
+ return value
+ }
+ });
+}
+
+var formatSortValue = exports.formatSortValue = function(sortDirection) {
+ var value = ("" + sortDirection).toLowerCase();
+
+ switch (value) {
+ case 'ascending':
+ case 'asc':
+ case '1':
+ return 1;
+ case 'descending':
+ case 'desc':
+ case '-1':
+ return -1;
+ default:
+ throw new Error("Illegal sort clause, must be of the form "
+ + "[['field1', '(ascending|descending)'], "
+ + "['field2', '(ascending|descending)']]");
+ }
+};
+
+var formattedOrderClause = exports.formattedOrderClause = function(sortValue) {
+ var orderBy = {};
+ if(sortValue == null) return null;
+ if (Array.isArray(sortValue)) {
+ if(sortValue.length === 0) {
+ return null;
+ }
+
+ for(var i = 0; i < sortValue.length; i++) {
+ if(sortValue[i].constructor == String) {
+ orderBy[sortValue[i]] = 1;
+ } else {
+ orderBy[sortValue[i][0]] = formatSortValue(sortValue[i][1]);
+ }
+ }
+ } else if(sortValue != null && typeof sortValue == 'object') {
+ orderBy = sortValue;
+ } else if (typeof sortValue == 'string') {
+ orderBy[sortValue] = 1;
+ } else {
+ throw new Error("Illegal sort clause, must be of the form " +
+ "[['field1', '(ascending|descending)'], ['field2', '(ascending|descending)']]");
+ }
+
+ return orderBy;
+};
+
+var checkCollectionName = function checkCollectionName (collectionName) {
+ if('string' !== typeof collectionName) {
+ throw Error("collection name must be a String");
+ }
+
+ if(!collectionName || collectionName.indexOf('..') != -1) {
+ throw Error("collection names cannot be empty");
+ }
+
+ if(collectionName.indexOf('$') != -1 &&
+ collectionName.match(/((^\$cmd)|(oplog\.\$main))/) == null) {
+ throw Error("collection names must not contain '$'");
+ }
+
+ if(collectionName.match(/^\.|\.$/) != null) {
+ throw Error("collection names must not start or end with '.'");
+ }
+
+ // Validate that we are not passing 0x00 in the colletion name
+ if(!!~collectionName.indexOf("\x00")) {
+ throw new Error("collection names cannot contain a null character");
+ }
+};
+
+var handleCallback = function(callback, err, value1, value2) {
+ try {
+ if(callback == null) return;
+ if(value2) return callback(err, value1, value2);
+ return callback(err, value1);
+ } catch(err) {
+ process.nextTick(function() { throw err; });
+ return false;
+ }
+
+ return true;
+}
+
+/**
+ * Wrap a Mongo error document in an Error instance
+ * @ignore
+ * @api private
+ */
+var toError = function(error) {
+ if (error instanceof Error) return error;
+
+ var msg = error.err || error.errmsg || error.errMessage || error;
+ var e = new MongoError(msg);
+
+ // Get all object keys
+ var keys = typeof error == 'object'
+ ? Object.keys(error)
+ : [];
+
+ for(var i = 0; i < keys.length; i++) {
+ e[keys[i]] = error[keys[i]];
+ }
+
+ return e;
+}
+
+/**
+ * @ignore
+ */
+var normalizeHintField = function normalizeHintField(hint) {
+ var finalHint = null;
+
+ if(typeof hint == 'string') {
+ finalHint = hint;
+ } else if(Array.isArray(hint)) {
+ finalHint = {};
+
+ hint.forEach(function(param) {
+ finalHint[param] = 1;
+ });
+ } else if(hint != null && typeof hint == 'object') {
+ finalHint = {};
+ for (var name in hint) {
+ finalHint[name] = hint[name];
+ }
+ }
+
+ return finalHint;
+};
+
+/**
+ * Create index name based on field spec
+ *
+ * @ignore
+ * @api private
+ */
+var parseIndexOptions = function(fieldOrSpec) {
+ var fieldHash = {};
+ var indexes = [];
+ var keys;
+
+ // Get all the fields accordingly
+ if('string' == typeof fieldOrSpec) {
+ // 'type'
+ indexes.push(fieldOrSpec + '_' + 1);
+ fieldHash[fieldOrSpec] = 1;
+ } else if(Array.isArray(fieldOrSpec)) {
+ fieldOrSpec.forEach(function(f) {
+ if('string' == typeof f) {
+ // [{location:'2d'}, 'type']
+ indexes.push(f + '_' + 1);
+ fieldHash[f] = 1;
+ } else if(Array.isArray(f)) {
+ // [['location', '2d'],['type', 1]]
+ indexes.push(f[0] + '_' + (f[1] || 1));
+ fieldHash[f[0]] = f[1] || 1;
+ } else if(isObject(f)) {
+ // [{location:'2d'}, {type:1}]
+ keys = Object.keys(f);
+ keys.forEach(function(k) {
+ indexes.push(k + '_' + f[k]);
+ fieldHash[k] = f[k];
+ });
+ } else {
+ // undefined (ignore)
+ }
+ });
+ } else if(isObject(fieldOrSpec)) {
+ // {location:'2d', type:1}
+ keys = Object.keys(fieldOrSpec);
+ keys.forEach(function(key) {
+ indexes.push(key + '_' + fieldOrSpec[key]);
+ fieldHash[key] = fieldOrSpec[key];
+ });
+ }
+
+ return {
+ name: indexes.join("_"), keys: keys, fieldHash: fieldHash
+ }
+}
+
+var isObject = exports.isObject = function (arg) {
+ return '[object Object]' == toString.call(arg)
+}
+
+var debugOptions = function(debugFields, options) {
+ var finaloptions = {};
+ debugFields.forEach(function(n) {
+ finaloptions[n] = options[n];
+ });
+
+ return finaloptions;
+}
+
+var decorateCommand = function(command, options, exclude) {
+ for(var name in options) {
+ if(exclude[name] == null) command[name] = options[name];
+ }
+
+ return command;
+}
+
+exports.shallowClone = shallowClone;
+exports.getSingleProperty = getSingleProperty;
+exports.checkCollectionName = checkCollectionName;
+exports.toError = toError;
+exports.formattedOrderClause = formattedOrderClause;
+exports.parseIndexOptions = parseIndexOptions;
+exports.normalizeHintField = normalizeHintField;
+exports.handleCallback = handleCallback;
+exports.decorateCommand = decorateCommand;
+exports.isObject = isObject;
+exports.debugOptions = debugOptions;
\ No newline at end of file
diff --git a/server/node_modules/mongodb/node_modules/mongodb-core/.travis.yml b/server/node_modules/mongodb/node_modules/mongodb-core/.travis.yml
new file mode 100755
index 00000000..04862d7d
--- /dev/null
+++ b/server/node_modules/mongodb/node_modules/mongodb-core/.travis.yml
@@ -0,0 +1,4 @@
+language: node_js
+node_js:
+ - 0.10
+ - 0.11
\ No newline at end of file
diff --git a/server/node_modules/mongodb/node_modules/mongodb-core/HISTORY.md b/server/node_modules/mongodb/node_modules/mongodb-core/HISTORY.md
new file mode 100755
index 00000000..eb110d3b
--- /dev/null
+++ b/server/node_modules/mongodb/node_modules/mongodb-core/HISTORY.md
@@ -0,0 +1,122 @@
+1.1.21 03-26-2015
+-----------------
+- Updated bson module to 0.3.0 that extracted the c++ parser into bson-ext and made it an optional dependency.
+
+1.1.20 03-24-2015
+-----------------
+- NODE-395 Socket Not Closing, db.close called before full set finished initalizing leading to server connections in progress not being closed properly.
+
+1.1.19 03-21-2015
+-----------------
+- Made kerberos module ~0.0 to allow for quicker releases due to io.js of kerberos module.
+
+1.1.18 03-17-2015
+-----------------
+- Added support for minHeartbeatFrequencyMS on server reconnect according to the SDAM specification.
+
+1.1.17 03-16-2015
+-----------------
+- NODE-377, fixed issue where tags would correctly be checked on secondary and nearest to filter out eligible server candidates.
+
+1.1.16 03-06-2015
+-----------------
+- rejectUnauthorized parameter is set to true for ssl certificates by default instead of false.
+
+1.1.15 03-04-2015
+-----------------
+- Removed check for type in replset pickserver function.
+
+1.1.14 02-26-2015
+-----------------
+- NODE-374 correctly adding passive secondaries to the list of eligable servers for reads
+
+1.1.13 02-24-2015
+-----------------
+- NODE-365 mongoDB native node.js driver infinite reconnect attempts (fixed issue around handling of retry attempts)
+
+1.1.12 02-16-2015
+-----------------
+- Fixed cursor transforms for buffered document reads from cursor.
+
+1.1.11 02-02-2015
+-----------------
+- Remove the required setName for replicaset connections, if not set it will pick the first setName returned.
+
+1.1.10 31-01-2015
+-----------------
+- Added tranforms.doc option to cursor to allow for pr. document transformations.
+
+1.1.9 21-01-2015
+----------------
+- Updated BSON dependency to 0.2.18 to fix issues with io.js and node.
+- Updated Kerberos dependency to 0.0.8 to fix issues with io.js and node.
+- Don't treat findOne() as a command cursor.
+- Refactored out state changes into methods to simplify read the next method.
+
+1.1.8 09-12-2015
+----------------
+- Stripped out Object.defineProperty for performance reasons
+- Applied more performance optimizations.
+- properties cursorBatchSize, cursorSkip, cursorLimit are not methods setCursorBatchSize/cursorBatchSize, setCursorSkip/cursorSkip, setCursorLimit/cursorLimit
+
+1.1.7 18-12-2014
+----------------
+- Use ns variable for getMore commands for command cursors to work properly with cursor version of listCollections and listIndexes.
+
+1.1.6 18-12-2014
+----------------
+- Server manager fixed to support 2.2.X servers for travis test matrix.
+
+1.1.5 17-12-2014
+----------------
+- Fall back to errmsg when creating MongoError for command errors
+
+1.1.4 17-12-2014
+----------------
+- Added transform method support for cursor (initially just for initial query results) to support listCollections/listIndexes in 2.8.
+- Fixed variable leak in scram.
+- Fixed server manager to deal better with killing processes.
+- Bumped bson to 0.2.16.
+
+1.1.3 01-12-2014
+----------------
+- Fixed error handling issue with nonce generation in mongocr.
+- Fixed issues with restarting servers when using ssl.
+- Using strict for all classes.
+- Cleaned up any escaping global variables.
+
+1.1.2 20-11-2014
+----------------
+- Correctly encoding UTF8 collection names on wire protocol messages.
+- Added emitClose parameter to topology destroy methods to allow users to specify that they wish the topology to emit the close event to any listeners.
+
+1.1.1 14-11-2014
+----------------
+- Refactored code to use prototype instead of privileged methods.
+- Fixed issue with auth where a runtime condition could leave replicaset members without proper authentication.
+- Several deopt optimizations for v8 to improve performance and reduce GC pauses.
+
+1.0.5 29-10-2014
+----------------
+- Fixed issue with wrong namespace being created for command cursors.
+
+1.0.4 24-10-2014
+----------------
+- switched from using shift for the cursor due to bad slowdown on big batchSizes as shift causes entire array to be copied on each call.
+
+1.0.3 21-10-2014
+----------------
+- fixed error issuing problem on cursor.next when iterating over a huge dataset with a very small batchSize.
+
+1.0.2 07-10-2014
+----------------
+- fullsetup is now defined as a primary and secondary being available allowing for all read preferences to be satisfied.
+- fixed issue with replset_state logging.
+
+1.0.1 07-10-2014
+----------------
+- Dependency issue solved
+
+1.0.0 07-10-2014
+----------------
+- Initial release of mongodb-core
diff --git a/server/node_modules/mongodb/node_modules/mongodb-core/LICENSE b/server/node_modules/mongodb/node_modules/mongodb-core/LICENSE
new file mode 100755
index 00000000..ad410e11
--- /dev/null
+++ b/server/node_modules/mongodb/node_modules/mongodb-core/LICENSE
@@ -0,0 +1,201 @@
+Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "{}"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright {yyyy} {name of copyright owner}
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
\ No newline at end of file
diff --git a/server/node_modules/mongodb/node_modules/mongodb-core/Makefile b/server/node_modules/mongodb/node_modules/mongodb-core/Makefile
new file mode 100755
index 00000000..e942bc63
--- /dev/null
+++ b/server/node_modules/mongodb/node_modules/mongodb-core/Makefile
@@ -0,0 +1,14 @@
+NODE = node
+NPM = npm
+JSDOC = jsdoc
+name = all
+
+generate_docs:
+ cp -R ./docs/history-header.md ./docs/content/meta/release-notes.md
+ more ./HISTORY.md >> ./docs/content/meta/release-notes.md
+ hugo -s docs/ -d ../public
+ $(JSDOC) -c conf.json -t docs/jsdoc-template/ -d ./public/api
+ cp -R ./public/api/scripts ./public/.
+ cp -R ./public/api/styles ./public/.
+
+.PHONY: total
diff --git a/server/node_modules/mongodb/node_modules/mongodb-core/README.md b/server/node_modules/mongodb/node_modules/mongodb-core/README.md
new file mode 100755
index 00000000..9275c8d3
--- /dev/null
+++ b/server/node_modules/mongodb/node_modules/mongodb-core/README.md
@@ -0,0 +1,225 @@
+# Description
+
+The MongoDB Core driver is the low level part of the 2.0 or higher MongoDB driver and is meant for library developers not end users. It does not contain any abstractions or helpers outside of the basic management of MongoDB topology connections, CRUD operations and authentication.
+
+## MongoDB Node.JS Core Driver
+
+| what | where |
+|---------------|------------------------------------------------|
+| documentation | http://mongodb.github.io/node-mongodb-native/ |
+| apidoc | http://mongodb.github.io/node-mongodb-native/ |
+| source | https://github.com/christkv/mongodb-core |
+| mongodb | http://www.mongodb.org/ |
+
+### Blogs of Engineers involved in the driver
+- Christian Kvalheim [@christkv](https://twitter.com/christkv)
+
+### Bugs / Feature Requests
+
+Think you’ve found a bug? Want to see a new feature in node-mongodb-native? Please open a
+case in our issue management tool, JIRA:
+
+- Create an account and login .
+- Navigate to the NODE project .
+- Click **Create Issue** - Please provide as much information as possible about the issue type and how to reproduce it.
+
+Bug reports in JIRA for all driver projects (i.e. NODE, PYTHON, CSHARP, JAVA) and the
+Core Server (i.e. SERVER) project are **public**.
+
+### Questions and Bug Reports
+
+ * mailing list: https://groups.google.com/forum/#!forum/node-mongodb-native
+ * jira: http://jira.mongodb.org/
+
+### Change Log
+
+http://jira.mongodb.org/browse/NODE
+
+# QuickStart
+
+The quick start guide will show you how to set up a simple application using Core driver and MongoDB. It scope is only how to set up the driver and perform the simple crud operations. For more inn depth coverage we encourage reading the tutorials.
+
+## Create the package.json file
+
+Let's create a directory where our application will live. In our case we will put this under our projects directory.
+
+```
+mkdir myproject
+cd myproject
+```
+
+Create a **package.json** using your favorite text editor and fill it in.
+
+```json
+{
+ "name": "myproject",
+ "version": "1.0.0",
+ "description": "My first project",
+ "main": "index.js",
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/christkv/myfirstproject.git"
+ },
+ "dependencies": {
+ "mongodb-core": "~1.0"
+ },
+ "author": "Christian Kvalheim",
+ "license": "Apache 2.0",
+ "bugs": {
+ "url": "https://github.com/christkv/myfirstproject/issues"
+ },
+ "homepage": "https://github.com/christkv/myfirstproject"
+}
+```
+
+Save the file and return to the shell or command prompt and use **NPM** to install all the dependencies.
+
+```
+npm install
+```
+
+You should see **NPM** download a lot of files. Once it's done you'll find all the downloaded packages under the **node_modules** directory.
+
+Booting up a MongoDB Server
+---------------------------
+Let's boot up a MongoDB server instance. Download the right MongoDB version from [MongoDB](http://www.mongodb.org), open a new shell or command line and ensure the **mongod** command is in the shell or command line path. Now let's create a database directory (in our case under **/data**).
+
+```
+mongod --dbpath=/data --port 27017
+```
+
+You should see the **mongod** process start up and print some status information.
+
+## Connecting to MongoDB
+
+Let's create a new **app.js** file that we will use to show the basic CRUD operations using the MongoDB driver.
+
+First let's add code to connect to the server. Notice that there is no concept of a database here and we use the topology directly to perform the connection.
+
+```js
+var Server = require('mongodb-core').Server
+ , assert = require('assert');
+
+// Set up server connection
+var server = new Server({
+ host: 'localhost'
+ , port: 27017
+ , reconnect: true
+ , reconnectInterval: 50
+});
+
+// Add event listeners
+server.on('connect', function(_server) {
+ console.log('connected');
+ test.done();
+});
+
+server.on('close', function() {
+ console.log('closed');
+});
+
+server.on('reconnect', function() {
+ console.log('reconnect');
+});
+
+// Start connection
+server.connect();
+```
+
+To connect to a replicaset we would use the `ReplSet` class and for a set of Mongos proxies we use the `Mongos` class. Each topology class offer the same CRUD operations and you operate on the topology directly. Let's look at an example exercising all the different available CRUD operations.
+
+```js
+var Server = require('mongodb-core').Server
+ , assert = require('assert');
+
+// Set up server connection
+var server = new Server({
+ host: 'localhost'
+ , port: 27017
+ , reconnect: true
+ , reconnectInterval: 50
+});
+
+// Add event listeners
+server.on('connect', function(_server) {
+ console.log('connected');
+
+ // Execute the ismaster command
+ _server.command('system.$cmd', {ismaster: true}, function(err, result) {
+
+ // Perform a document insert
+ _server.insert('myproject.inserts1', [{a:1}, {a:2}], {
+ writeConcern: {w:1}, ordered:true
+ }, function(err, results) {
+ assert.equal(null, err);
+ assert.equal(2, results.result.n);
+
+ // Perform a document update
+ _server.update('myproject.inserts1', [{
+ q: {a: 1}, u: {'$set': {b:1}}
+ }], {
+ writeConcern: {w:1}, ordered:true
+ }, function(err, results) {
+ assert.equal(null, err);
+ assert.equal(1, results.result.n);
+
+ // Remove a document
+ _server.remove('myproject.inserts1', [{
+ q: {a: 1}, limit: 1
+ }], {
+ writeConcern: {w:1}, ordered:true
+ }, function(err, results) {
+ assert.equal(null, err);
+ assert.equal(1, results.result.n);
+
+ // Get a document
+ var cursor = _server.cursor('integration_tests.inserts_example4', {
+ find: 'integration_tests.example4'
+ , query: {a:1}
+ });
+
+ // Get the first document
+ cursor.next(function(err, doc) {
+ assert.equal(null, err);
+ assert.equal(2, doc.a);
+
+ // Execute the ismaster command
+ _server.command("system.$cmd"
+ , {ismaster: true}, function(err, result) {
+ assert.equal(null, err)
+ _server.destroy();
+ });
+ });
+ });
+ });
+
+ test.done();
+ });
+});
+
+server.on('close', function() {
+ console.log('closed');
+});
+
+server.on('reconnect', function() {
+ console.log('reconnect');
+});
+
+// Start connection
+server.connect();
+```
+
+The core driver does not contain any helpers or abstractions only the core crud operations. These consist of the following commands.
+
+* `insert`, Insert takes an array of 1 or more documents to be inserted against the topology and allows you to specify a write concern and if you wish to execute the inserts in order or out of order.
+* `update`, Update takes an array of 1 or more update commands to be executed against the server topology and also allows you to specify a write concern and if you wish to execute the updates in order or out of order.
+* `remove`, Remove takes an array of 1 or more remove commands to be executed against the server topology and also allows you to specify a write concern and if you wish to execute the removes in order or out of order.
+* `cursor`, Returns you a cursor for either the 'virtual' `find` command, a command that returns a cursor id or a plain cursor id. Read the cursor tutorial for more inn depth coverage.
+* `command`, Executes a command against MongoDB and returns the result.
+* `auth`, Authenticates the current topology using a supported authentication scheme.
+
+The Core Driver is a building block for library builders and is not meant for usage by end users as it lacks a lot of features the end user might need such as automatic buffering of operations when a primary is changing in a replicaset or the db and collections abstraction.
+
+## Next steps
+
+The next steps is to get more inn depth information about how the different aspects of the core driver works and how to leverage them to extend the functionality of the cursors. Please view the tutorials for more detailed information.
diff --git a/server/node_modules/mongodb/node_modules/mongodb-core/TESTING.md b/server/node_modules/mongodb/node_modules/mongodb-core/TESTING.md
new file mode 100755
index 00000000..fe03ea0f
--- /dev/null
+++ b/server/node_modules/mongodb/node_modules/mongodb-core/TESTING.md
@@ -0,0 +1,18 @@
+Testing setup
+=============
+
+Single Server
+-------------
+mongod --dbpath=./db
+
+Replicaset
+----------
+mongo --nodb
+var x = new ReplSetTest({"useHostName":"false", "nodes" : {node0 : {}, node1 : {}, node2 : {}}})
+x.startSet();
+var config = x.getReplSetConfig()
+x.initiate(config);
+
+Mongos
+------
+var s = new ShardingTest( "auth1", 1 , 0 , 2 , {rs: true, noChunkSize : true});
\ No newline at end of file
diff --git a/server/node_modules/mongodb/node_modules/mongodb-core/conf.json b/server/node_modules/mongodb/node_modules/mongodb-core/conf.json
new file mode 100755
index 00000000..c5eca926
--- /dev/null
+++ b/server/node_modules/mongodb/node_modules/mongodb-core/conf.json
@@ -0,0 +1,60 @@
+{
+ "plugins": ["plugins/markdown", "docs/lib/jsdoc/examples_plugin.js"],
+ "source": {
+ "include": [
+ "test/tests/functional/operation_example_tests.js",
+ "lib/topologies/mongos.js",
+ "lib/topologies/command_result.js",
+ "lib/topologies/read_preference.js",
+ "lib/topologies/replset.js",
+ "lib/topologies/server.js",
+ "lib/topologies/session.js",
+ "lib/topologies/replset_state.js",
+ "lib/connection/logger.js",
+ "lib/connection/connection.js",
+ "lib/cursor.js",
+ "lib/error.js",
+ "node_modules/bson/lib/bson/binary.js",
+ "node_modules/bson/lib/bson/code.js",
+ "node_modules/bson/lib/bson/db_ref.js",
+ "node_modules/bson/lib/bson/double.js",
+ "node_modules/bson/lib/bson/long.js",
+ "node_modules/bson/lib/bson/objectid.js",
+ "node_modules/bson/lib/bson/symbol.js",
+ "node_modules/bson/lib/bson/timestamp.js",
+ "node_modules/bson/lib/bson/max_key.js",
+ "node_modules/bson/lib/bson/min_key.js"
+ ]
+ },
+ "templates": {
+ "cleverLinks": true,
+ "monospaceLinks": true,
+ "default": {
+ "outputSourceFiles" : true
+ },
+ "applicationName": "Node.js MongoDB Driver API",
+ "disqus": true,
+ "googleAnalytics": "UA-29229787-1",
+ "openGraph": {
+ "title": "",
+ "type": "website",
+ "image": "",
+ "site_name": "",
+ "url": ""
+ },
+ "meta": {
+ "title": "",
+ "description": "",
+ "keyword": ""
+ },
+ "linenums": true
+ },
+ "markdown": {
+ "parser": "gfm",
+ "hardwrap": true,
+ "tags": ["examples"]
+ },
+ "examples": {
+ "indent": 4
+ }
+}
\ No newline at end of file
diff --git a/server/node_modules/mongodb/node_modules/mongodb-core/index.js b/server/node_modules/mongodb/node_modules/mongodb-core/index.js
new file mode 100755
index 00000000..60c9d532
--- /dev/null
+++ b/server/node_modules/mongodb/node_modules/mongodb-core/index.js
@@ -0,0 +1,17 @@
+module.exports = {
+ MongoError: require('./lib/error')
+ , Server: require('./lib/topologies/server')
+ , ReplSet: require('./lib/topologies/replset')
+ , Mongos: require('./lib/topologies/mongos')
+ , Logger: require('./lib/connection/logger')
+ , Cursor: require('./lib/cursor')
+ , ReadPreference: require('./lib/topologies/read_preference')
+ , BSON: require('bson')
+ // Raw operations
+ , Query: require('./lib/connection/commands').Query
+ // Auth mechanisms
+ , MongoCR: require('./lib/auth/mongocr')
+ , X509: require('./lib/auth/x509')
+ , Plain: require('./lib/auth/plain')
+ , GSSAPI: require('./lib/auth/gssapi')
+}
\ No newline at end of file
diff --git a/server/node_modules/mongodb/node_modules/mongodb-core/lib/auth/gssapi.js b/server/node_modules/mongodb/node_modules/mongodb-core/lib/auth/gssapi.js
new file mode 100755
index 00000000..c442b9b0
--- /dev/null
+++ b/server/node_modules/mongodb/node_modules/mongodb-core/lib/auth/gssapi.js
@@ -0,0 +1,244 @@
+"use strict";
+
+var f = require('util').format
+ , crypto = require('crypto')
+ , MongoError = require('../error');
+
+var AuthSession = function(db, username, password, options) {
+ this.db = db;
+ this.username = username;
+ this.password = password;
+ this.options = options;
+}
+
+AuthSession.prototype.equal = function(session) {
+ return session.db == this.db
+ && session.username == this.username
+ && session.password == this.password;
+}
+
+// Kerberos class
+var Kerberos = null;
+var MongoAuthProcess = null;
+
+// Try to grab the Kerberos class
+try {
+ Kerberos = require('kerberos').Kerberos
+ // Authentication process for Mongo
+ MongoAuthProcess = require('kerberos').processes.MongoAuthProcess
+} catch(err) {}
+
+/**
+ * Creates a new GSSAPI authentication mechanism
+ * @class
+ * @return {GSSAPI} A cursor instance
+ */
+var GSSAPI = function() {
+ this.authStore = [];
+}
+
+/**
+ * Authenticate
+ * @method
+ * @param {{Server}|{ReplSet}|{Mongos}} server Topology the authentication method is being called on
+ * @param {Pool} pool Connection pool for this topology
+ * @param {string} db Name of the database
+ * @param {string} username Username
+ * @param {string} password Password
+ * @param {authResultCallback} callback The callback to return the result from the authentication
+ * @return {object}
+ */
+GSSAPI.prototype.auth = function(server, pool, db, username, password, options, callback) {
+ var self = this;
+ // We don't have the Kerberos library
+ if(Kerberos == null) return callback(new Error("Kerberos library is not installed"));
+ var gssapiServiceName = options['gssapiServiceName'] || 'mongodb';
+ // Get all the connections
+ var connections = pool.getAll();
+ // Total connections
+ var count = connections.length;
+ if(count == 0) return callback(null, null);
+
+ // Valid connections
+ var numberOfValidConnections = 0;
+ var credentialsValid = false;
+ var errorObject = null;
+
+ // For each connection we need to authenticate
+ while(connections.length > 0) {
+ // Execute MongoCR
+ var execute = function(connection) {
+ // Start Auth process for a connection
+ GSSAPIInitialize(db, username, password, db, gssapiServiceName, server, connection, function(err, r) {
+ // Adjust count
+ count = count - 1;
+
+ // If we have an error
+ if(err) {
+ errorObject = err;
+ } else if(r.result['$err']) {
+ errorObject = r.result;
+ } else if(r.result['errmsg']) {
+ errorObject = r.result;
+ } else {
+ credentialsValid = true;
+ numberOfValidConnections = numberOfValidConnections + 1;
+ }
+
+ // We have authenticated all connections
+ if(count == 0 && numberOfValidConnections > 0) {
+ // Store the auth details
+ addAuthSession(self.authStore, new AuthSession(db, username, password, options));
+ // Return correct authentication
+ callback(null, true);
+ } else if(count == 0) {
+ if(errorObject == null) errorObject = new MongoError(f("failed to authenticate using mongocr"));
+ callback(errorObject, false);
+ }
+ });
+ }
+
+ // Get the connection
+ execute(connections.shift());
+ }
+}
+
+//
+// Initialize step
+var GSSAPIInitialize = function(db, username, password, authdb, gssapiServiceName, server, connection, callback) {
+ // Create authenticator
+ var mongo_auth_process = new MongoAuthProcess(connection.host, connection.port, gssapiServiceName);
+
+ // Perform initialization
+ mongo_auth_process.init(username, password, function(err, context) {
+ if(err) return callback(err, false);
+
+ // Perform the first step
+ mongo_auth_process.transition('', function(err, payload) {
+ if(err) return callback(err, false);
+
+ // Call the next db step
+ MongoDBGSSAPIFirstStep(mongo_auth_process, payload, db, username, password, authdb, server, connection, callback);
+ });
+ });
+}
+
+//
+// Perform first step against mongodb
+var MongoDBGSSAPIFirstStep = function(mongo_auth_process, payload, db, username, password, authdb, server, connection, callback) {
+ // Build the sasl start command
+ var command = {
+ saslStart: 1
+ , mechanism: 'GSSAPI'
+ , payload: payload
+ , autoAuthorize: 1
+ };
+
+ // Execute first sasl step
+ server.command("$external.$cmd"
+ , command
+ , { connection: connection }, function(err, r) {
+ if(err) return callback(err, false);
+ var doc = r.result;
+ // Execute mongodb transition
+ mongo_auth_process.transition(r.result.payload, function(err, payload) {
+ if(err) return callback(err, false);
+
+ // MongoDB API Second Step
+ MongoDBGSSAPISecondStep(mongo_auth_process, payload, doc, db, username, password, authdb, server, connection, callback);
+ });
+ });
+}
+
+//
+// Perform first step against mongodb
+var MongoDBGSSAPISecondStep = function(mongo_auth_process, payload, doc, db, username, password, authdb, server, connection, callback) {
+ // Build Authentication command to send to MongoDB
+ var command = {
+ saslContinue: 1
+ , conversationId: doc.conversationId
+ , payload: payload
+ };
+
+ // Execute the command
+ server.command("$external.$cmd"
+ , command
+ , { connection: connection }, function(err, r) {
+ if(err) return callback(err, false);
+ var doc = r.result;
+ // Call next transition for kerberos
+ mongo_auth_process.transition(doc.payload, function(err, payload) {
+ if(err) return callback(err, false);
+
+ // Call the last and third step
+ MongoDBGSSAPIThirdStep(mongo_auth_process, payload, doc, db, username, password, authdb, server, connection, callback);
+ });
+ });
+}
+
+var MongoDBGSSAPIThirdStep = function(mongo_auth_process, payload, doc, db, username, password, authdb, server, connection, callback) {
+ // Build final command
+ var command = {
+ saslContinue: 1
+ , conversationId: doc.conversationId
+ , payload: payload
+ };
+
+ // Execute the command
+ server.command("$external.$cmd"
+ , command
+ , { connection: connection }, function(err, r) {
+ if(err) return callback(err, false);
+ mongo_auth_process.transition(null, function(err, payload) {
+ if(err) return callback(err, null);
+ callback(null, r);
+ });
+ });
+}
+
+// Add to store only if it does not exist
+var addAuthSession = function(authStore, session) {
+ var found = false;
+
+ for(var i = 0; i < authStore.length; i++) {
+ if(authStore[i].equal(session)) {
+ found = true;
+ break;
+ }
+ }
+
+ if(!found) authStore.push(session);
+}
+
+/**
+ * Re authenticate pool
+ * @method
+ * @param {{Server}|{ReplSet}|{Mongos}} server Topology the authentication method is being called on
+ * @param {Pool} pool Connection pool for this topology
+ * @param {authResultCallback} callback The callback to return the result from the authentication
+ * @return {object}
+ */
+GSSAPI.prototype.reauthenticate = function(server, pool, callback) {
+ var count = this.authStore.length;
+ if(count == 0) return callback(null, null);
+ // Iterate over all the auth details stored
+ for(var i = 0; i < this.authStore.length; i++) {
+ this.auth(server, pool, this.authStore[i].db, this.authStore[i].username, this.authStore[i].password, this.authStore[i].options, function(err, r) {
+ count = count - 1;
+ // Done re-authenticating
+ if(count == 0) {
+ callback(null, null);
+ }
+ });
+ }
+}
+
+/**
+ * This is a result from a authentication strategy
+ *
+ * @callback authResultCallback
+ * @param {error} error An error object. Set to null if no error present
+ * @param {boolean} result The result of the authentication process
+ */
+
+module.exports = GSSAPI;
\ No newline at end of file
diff --git a/server/node_modules/mongodb/node_modules/mongodb-core/lib/auth/mongocr.js b/server/node_modules/mongodb/node_modules/mongodb-core/lib/auth/mongocr.js
new file mode 100755
index 00000000..d0e9f59b
--- /dev/null
+++ b/server/node_modules/mongodb/node_modules/mongodb-core/lib/auth/mongocr.js
@@ -0,0 +1,160 @@
+"use strict";
+
+var f = require('util').format
+ , crypto = require('crypto')
+ , MongoError = require('../error');
+
+var AuthSession = function(db, username, password) {
+ this.db = db;
+ this.username = username;
+ this.password = password;
+}
+
+AuthSession.prototype.equal = function(session) {
+ return session.db == this.db
+ && session.username == this.username
+ && session.password == this.password;
+}
+
+/**
+ * Creates a new MongoCR authentication mechanism
+ * @class
+ * @return {MongoCR} A cursor instance
+ */
+var MongoCR = function() {
+ this.authStore = [];
+}
+
+// Add to store only if it does not exist
+var addAuthSession = function(authStore, session) {
+ var found = false;
+
+ for(var i = 0; i < authStore.length; i++) {
+ if(authStore[i].equal(session)) {
+ found = true;
+ break;
+ }
+ }
+
+ if(!found) authStore.push(session);
+}
+
+/**
+ * Authenticate
+ * @method
+ * @param {{Server}|{ReplSet}|{Mongos}} server Topology the authentication method is being called on
+ * @param {Pool} pool Connection pool for this topology
+ * @param {string} db Name of the database
+ * @param {string} username Username
+ * @param {string} password Password
+ * @param {authResultCallback} callback The callback to return the result from the authentication
+ * @return {object}
+ */
+MongoCR.prototype.auth = function(server, pool, db, username, password, callback) {
+ var self = this;
+ // Get all the connections
+ var connections = pool.getAll();
+ // Total connections
+ var count = connections.length;
+ if(count == 0) return callback(null, null);
+
+ // Valid connections
+ var numberOfValidConnections = 0;
+ var credentialsValid = false;
+ var errorObject = null;
+
+ // For each connection we need to authenticate
+ while(connections.length > 0) {
+ // Execute MongoCR
+ var executeMongoCR = function(connection) {
+ // Let's start the process
+ server.command(f("%s.$cmd", db)
+ , { getnonce: 1 }
+ , { connection: connection }, function(err, r) {
+ var nonce = null;
+ var key = null;
+
+ // Adjust the number of connections left
+ // Get nonce
+ if(err == null) {
+ nonce = r.result.nonce;
+ // Use node md5 generator
+ var md5 = crypto.createHash('md5');
+ // Generate keys used for authentication
+ md5.update(username + ":mongo:" + password);
+ var hash_password = md5.digest('hex');
+ // Final key
+ md5 = crypto.createHash('md5');
+ md5.update(nonce + username + hash_password);
+ key = md5.digest('hex');
+ }
+
+ // Execute command
+ server.command(f("%s.$cmd", db)
+ , { authenticate: 1, user: username, nonce: nonce, key:key}
+ , { connection: connection }, function(err, r) {
+ count = count - 1;
+
+ // If we have an error
+ if(err) {
+ errorObject = err;
+ } else if(r.result['$err']) {
+ errorObject = r.result;
+ } else if(r.result['errmsg']) {
+ errorObject = r.result;
+ } else {
+ credentialsValid = true;
+ numberOfValidConnections = numberOfValidConnections + 1;
+ }
+
+ // We have authenticated all connections
+ if(count == 0 && numberOfValidConnections > 0) {
+ // Store the auth details
+ addAuthSession(self.authStore, new AuthSession(db, username, password));
+ // Return correct authentication
+ callback(null, true);
+ } else if(count == 0) {
+ if(errorObject == null) errorObject = new MongoError(f("failed to authenticate using mongocr"));
+ callback(errorObject, false);
+ }
+ });
+ });
+ }
+
+ // Get the connection
+ executeMongoCR(connections.shift());
+ }
+}
+
+/**
+ * Re authenticate pool
+ * @method
+ * @param {{Server}|{ReplSet}|{Mongos}} server Topology the authentication method is being called on
+ * @param {Pool} pool Connection pool for this topology
+ * @param {authResultCallback} callback The callback to return the result from the authentication
+ * @return {object}
+ */
+MongoCR.prototype.reauthenticate = function(server, pool, callback) {
+ var count = this.authStore.length;
+ if(count == 0) return callback(null, null);
+ // Iterate over all the auth details stored
+ for(var i = 0; i < this.authStore.length; i++) {
+ this.auth(server, pool, this.authStore[i].db, this.authStore[i].username, this.authStore[i].password, function(err, r) {
+ count = count - 1;
+ // Done re-authenticating
+ if(count == 0) {
+ callback(null, null);
+ }
+ });
+ }
+}
+
+/**
+ * This is a result from a authentication strategy
+ *
+ * @callback authResultCallback
+ * @param {error} error An error object. Set to null if no error present
+ * @param {boolean} result The result of the authentication process
+ */
+
+module.exports = MongoCR;
\ No newline at end of file
diff --git a/server/node_modules/mongodb/node_modules/mongodb-core/lib/auth/plain.js b/server/node_modules/mongodb/node_modules/mongodb-core/lib/auth/plain.js
new file mode 100755
index 00000000..31ce8722
--- /dev/null
+++ b/server/node_modules/mongodb/node_modules/mongodb-core/lib/auth/plain.js
@@ -0,0 +1,150 @@
+"use strict";
+
+var f = require('util').format
+ , crypto = require('crypto')
+ , Binary = require('bson').Binary
+ , MongoError = require('../error');
+
+var AuthSession = function(db, username, password) {
+ this.db = db;
+ this.username = username;
+ this.password = password;
+}
+
+AuthSession.prototype.equal = function(session) {
+ return session.db == this.db
+ && session.username == this.username
+ && session.password == this.password;
+}
+
+/**
+ * Creates a new Plain authentication mechanism
+ * @class
+ * @return {Plain} A cursor instance
+ */
+var Plain = function() {
+ this.authStore = [];
+}
+
+/**
+ * Authenticate
+ * @method
+ * @param {{Server}|{ReplSet}|{Mongos}} server Topology the authentication method is being called on
+ * @param {Pool} pool Connection pool for this topology
+ * @param {string} db Name of the database
+ * @param {string} username Username
+ * @param {string} password Password
+ * @param {authResultCallback} callback The callback to return the result from the authentication
+ * @return {object}
+ */
+Plain.prototype.auth = function(server, pool, db, username, password, callback) {
+ var self = this;
+ // Get all the connections
+ var connections = pool.getAll();
+ // Total connections
+ var count = connections.length;
+ if(count == 0) return callback(null, null);
+
+ // Valid connections
+ var numberOfValidConnections = 0;
+ var credentialsValid = false;
+ var errorObject = null;
+
+ // For each connection we need to authenticate
+ while(connections.length > 0) {
+ // Execute MongoCR
+ var execute = function(connection) {
+ // Create payload
+ var payload = new Binary(f("\x00%s\x00%s", username, password));
+
+ // Let's start the sasl process
+ var command = {
+ saslStart: 1
+ , mechanism: 'PLAIN'
+ , payload: payload
+ , autoAuthorize: 1
+ };
+
+ // Let's start the process
+ server.command("$external.$cmd"
+ , command
+ , { connection: connection }, function(err, r) {
+ // Adjust count
+ count = count - 1;
+
+ // If we have an error
+ if(err) {
+ errorObject = err;
+ } else if(r.result['$err']) {
+ errorObject = r.result;
+ } else if(r.result['errmsg']) {
+ errorObject = r.result;
+ } else {
+ credentialsValid = true;
+ numberOfValidConnections = numberOfValidConnections + 1;
+ }
+
+ // We have authenticated all connections
+ if(count == 0 && numberOfValidConnections > 0) {
+ // Store the auth details
+ addAuthSession(self.authStore, new AuthSession(db, username, password));
+ // Return correct authentication
+ callback(null, true);
+ } else if(count == 0) {
+ if(errorObject == null) errorObject = new MongoError(f("failed to authenticate using mongocr"));
+ callback(errorObject, false);
+ }
+ });
+ }
+
+ // Get the connection
+ execute(connections.shift());
+ }
+}
+
+// Add to store only if it does not exist
+var addAuthSession = function(authStore, session) {
+ var found = false;
+
+ for(var i = 0; i < authStore.length; i++) {
+ if(authStore[i].equal(session)) {
+ found = true;
+ break;
+ }
+ }
+
+ if(!found) authStore.push(session);
+}
+
+/**
+ * Re authenticate pool
+ * @method
+ * @param {{Server}|{ReplSet}|{Mongos}} server Topology the authentication method is being called on
+ * @param {Pool} pool Connection pool for this topology
+ * @param {authResultCallback} callback The callback to return the result from the authentication
+ * @return {object}
+ */
+Plain.prototype.reauthenticate = function(server, pool, callback) {
+ var count = this.authStore.length;
+ if(count == 0) return callback(null, null);
+ // Iterate over all the auth details stored
+ for(var i = 0; i < this.authStore.length; i++) {
+ this.auth(server, pool, this.authStore[i].db, this.authStore[i].username, this.authStore[i].password, function(err, r) {
+ count = count - 1;
+ // Done re-authenticating
+ if(count == 0) {
+ callback(null, null);
+ }
+ });
+ }
+}
+
+/**
+ * This is a result from a authentication strategy
+ *
+ * @callback authResultCallback
+ * @param {error} error An error object. Set to null if no error present
+ * @param {boolean} result The result of the authentication process
+ */
+
+module.exports = Plain;
\ No newline at end of file
diff --git a/server/node_modules/mongodb/node_modules/mongodb-core/lib/auth/scram.js b/server/node_modules/mongodb/node_modules/mongodb-core/lib/auth/scram.js
new file mode 100755
index 00000000..a22de1d5
--- /dev/null
+++ b/server/node_modules/mongodb/node_modules/mongodb-core/lib/auth/scram.js
@@ -0,0 +1,317 @@
+"use strict";
+
+var f = require('util').format
+ , crypto = require('crypto')
+ , Binary = require('bson').Binary
+ , MongoError = require('../error');
+
+var AuthSession = function(db, username, password) {
+ this.db = db;
+ this.username = username;
+ this.password = password;
+}
+
+AuthSession.prototype.equal = function(session) {
+ return session.db == this.db
+ && session.username == this.username
+ && session.password == this.password;
+}
+
+/**
+ * Creates a new ScramSHA1 authentication mechanism
+ * @class
+ * @return {ScramSHA1} A cursor instance
+ */
+var ScramSHA1 = function() {
+ this.authStore = [];
+}
+
+var parsePayload = function(payload) {
+ var dict = {};
+ var parts = payload.split(',');
+
+ for(var i = 0; i < parts.length; i++) {
+ var valueParts = parts[i].split('=');
+ dict[valueParts[0]] = valueParts[1];
+ }
+
+ return dict;
+}
+
+var passwordDigest = function(username, password) {
+ if(typeof username != 'string') throw new MongoError("username must be a string");
+ if(typeof password != 'string') throw new MongoError("password must be a string");
+ if(password.length == 0) throw new MongoError("password cannot be empty");
+ // Use node md5 generator
+ var md5 = crypto.createHash('md5');
+ // Generate keys used for authentication
+ md5.update(username + ":mongo:" + password);
+ return md5.digest('hex');
+}
+
+// XOR two buffers
+var xor = function(a, b) {
+ if (!Buffer.isBuffer(a)) a = new Buffer(a)
+ if (!Buffer.isBuffer(b)) b = new Buffer(b)
+ var res = []
+ if (a.length > b.length) {
+ for (var i = 0; i < b.length; i++) {
+ res.push(a[i] ^ b[i])
+ }
+ } else {
+ for (var i = 0; i < a.length; i++) {
+ res.push(a[i] ^ b[i])
+ }
+ }
+ return new Buffer(res);
+}
+
+// Create a final digest
+var hi = function(data, salt, iterations) {
+ // Create digest
+ var digest = function(msg) {
+ var hmac = crypto.createHmac('sha1', data);
+ hmac.update(msg);
+ var result = hmac.digest()
+ return result;
+ }
+
+ // Create variables
+ salt = Buffer.concat([salt, new Buffer('\x00\x00\x00\x01')])
+ var ui = digest(salt);
+ var u1 = ui;
+
+ for(var i = 0; i < iterations - 1; i++) {
+ u1 = digest(u1);
+ ui = xor(ui, u1);
+ }
+
+ return ui;
+}
+
+/**
+ * Authenticate
+ * @method
+ * @param {{Server}|{ReplSet}|{Mongos}} server Topology the authentication method is being called on
+ * @param {Pool} pool Connection pool for this topology
+ * @param {string} db Name of the database
+ * @param {string} username Username
+ * @param {string} password Password
+ * @param {authResultCallback} callback The callback to return the result from the authentication
+ * @return {object}
+ */
+ScramSHA1.prototype.auth = function(server, pool, db, username, password, callback) {
+ var self = this;
+ // Get all the connections
+ var connections = pool.getAll();
+ // Total connections
+ var count = connections.length;
+ if(count == 0) return callback(null, null);
+
+ // Valid connections
+ var numberOfValidConnections = 0;
+ var credentialsValid = false;
+ var errorObject = null;
+
+ // For each connection we need to authenticate
+ while(connections.length > 0) {
+ // Execute MongoCR
+ var executeScram = function(connection) {
+ // Clean up the user
+ username = username.replace('=', "=3D").replace(',', '=2C');
+
+ // Create a random nonce
+ var nonce = crypto.randomBytes(24).toString('base64');
+ // var nonce = 'MsQUY9iw0T9fx2MUEz6LZPwGuhVvWAhc'
+ var firstBare = f("n=%s,r=%s", username, nonce);
+
+ // Build command structure
+ var cmd = {
+ saslStart: 1
+ , mechanism: 'SCRAM-SHA-1'
+ , payload: new Binary(f("n,,%s", firstBare))
+ , autoAuthorize: 1
+ }
+
+ // Handle the error
+ var handleError = function(err, r) {
+ if(err) {
+ errorObject = err; return false;
+ } else if(r.result['$err']) {
+ errorObject = r.result; return false;
+ } else if(r.result['errmsg']) {
+ errorObject = r.result; return false;
+ } else {
+ credentialsValid = true;
+ numberOfValidConnections = numberOfValidConnections + 1;
+ }
+
+ return true
+ }
+
+ // Finish up
+ var finish = function(_count, _numberOfValidConnections) {
+ if(_count == 0 && _numberOfValidConnections > 0) {
+ // Store the auth details
+ addAuthSession(self.authStore, new AuthSession(db, username, password));
+ // Return correct authentication
+ return callback(null, true);
+ } else if(_count == 0) {
+ if(errorObject == null) errorObject = new MongoError(f("failed to authenticate using scram"));
+ return callback(errorObject, false);
+ }
+ }
+
+ var handleEnd = function(_err, _r) {
+ // Handle any error
+ handleError(_err, _r)
+ // Adjust the number of connections
+ count = count - 1;
+ // Execute the finish
+ finish(count, numberOfValidConnections);
+ }
+
+ // Execute start sasl command
+ server.command(f("%s.$cmd", db)
+ , cmd, { connection: connection }, function(err, r) {
+
+ // Do we have an error, handle it
+ if(handleError(err, r) == false) {
+ count = count - 1;
+
+ if(count == 0 && numberOfValidConnections > 0) {
+ // Store the auth details
+ addAuthSession(self.authStore, new AuthSession(db, username, password));
+ // Return correct authentication
+ return callback(null, true);
+ } else if(count == 0) {
+ if(errorObject == null) errorObject = new MongoError(f("failed to authenticate using scram"));
+ return callback(errorObject, false);
+ }
+
+ return;
+ }
+
+ // Get the dictionary
+ var dict = parsePayload(r.result.payload.value())
+
+ // Unpack dictionary
+ var iterations = parseInt(dict.i, 10);
+ var salt = dict.s;
+ var rnonce = dict.r;
+
+ // Set up start of proof
+ var withoutProof = f("c=biws,r=%s", rnonce);
+ var passwordDig = passwordDigest(username, password);
+ var saltedPassword = hi(passwordDig
+ , new Buffer(salt, 'base64')
+ , iterations);
+
+ // Create the client key
+ var hmac = crypto.createHmac('sha1', saltedPassword);
+ hmac.update(new Buffer("Client Key"));
+ var clientKey = hmac.digest();
+
+ // Create the stored key
+ var hash = crypto.createHash('sha1');
+ hash.update(clientKey);
+ var storedKey = hash.digest();
+
+ // Create the authentication message
+ var authMsg = [firstBare, r.result.payload.value().toString('base64'), withoutProof].join(',');
+
+ // Create client signature
+ var hmac = crypto.createHmac('sha1', storedKey);
+ hmac.update(new Buffer(authMsg));
+ var clientSig = hmac.digest();
+
+ // Create client proof
+ var clientProof = f("p=%s", new Buffer(xor(clientKey, clientSig)).toString('base64'));
+
+ // Create client final
+ var clientFinal = [withoutProof, clientProof].join(',');
+
+ // Generate server key
+ var hmac = crypto.createHmac('sha1', saltedPassword);
+ hmac.update(new Buffer('Server Key'))
+ var serverKey = hmac.digest();
+
+ // Generate server signature
+ var hmac = crypto.createHmac('sha1', serverKey);
+ hmac.update(new Buffer(authMsg))
+ var serverSig = hmac.digest();
+
+ //
+ // Create continue message
+ var cmd = {
+ saslContinue: 1
+ , conversationId: r.result.conversationId
+ , payload: new Binary(new Buffer(clientFinal))
+ }
+
+ //
+ // Execute sasl continue
+ server.command(f("%s.$cmd", db)
+ , cmd, { connection: connection }, function(err, r) {
+ if(r && r.result.done == false) {
+ var cmd = {
+ saslContinue: 1
+ , conversationId: r.result.conversationId
+ , payload: new Buffer(0)
+ }
+
+ server.command(f("%s.$cmd", db)
+ , cmd, { connection: connection }, function(err, r) {
+ handleEnd(err, r);
+ });
+ } else {
+ handleEnd(err, r);
+ }
+ });
+ });
+ }
+
+ // Get the connection
+ executeScram(connections.shift());
+ }
+}
+
+// Add to store only if it does not exist
+var addAuthSession = function(authStore, session) {
+ var found = false;
+
+ for(var i = 0; i < authStore.length; i++) {
+ if(authStore[i].equal(session)) {
+ found = true;
+ break;
+ }
+ }
+
+ if(!found) authStore.push(session);
+}
+
+/**
+ * Re authenticate pool
+ * @method
+ * @param {{Server}|{ReplSet}|{Mongos}} server Topology the authentication method is being called on
+ * @param {Pool} pool Connection pool for this topology
+ * @param {authResultCallback} callback The callback to return the result from the authentication
+ * @return {object}
+ */
+ScramSHA1.prototype.reauthenticate = function(server, pool, callback) {
+ var count = this.authStore.length;
+ if(count == 0) return callback(null, null);
+ // Iterate over all the auth details stored
+ for(var i = 0; i < this.authStore.length; i++) {
+ this.auth(server, pool, this.authStore[i].db, this.authStore[i].username, this.authStore[i].password, function(err, r) {
+ count = count - 1;
+ // Done re-authenticating
+ if(count == 0) {
+ callback(null, null);
+ }
+ });
+ }
+}
+
+
+module.exports = ScramSHA1;
\ No newline at end of file
diff --git a/server/node_modules/mongodb/node_modules/mongodb-core/lib/auth/sspi.js b/server/node_modules/mongodb/node_modules/mongodb-core/lib/auth/sspi.js
new file mode 100755
index 00000000..177ede57
--- /dev/null
+++ b/server/node_modules/mongodb/node_modules/mongodb-core/lib/auth/sspi.js
@@ -0,0 +1,234 @@
+"use strict";
+
+var f = require('util').format
+ , crypto = require('crypto')
+ , MongoError = require('../error');
+
+var AuthSession = function(db, username, password, options) {
+ this.db = db;
+ this.username = username;
+ this.password = password;
+ this.options = options;
+}
+
+AuthSession.prototype.equal = function(session) {
+ return session.db == this.db
+ && session.username == this.username
+ && session.password == this.password;
+}
+
+// Kerberos class
+var Kerberos = null;
+var MongoAuthProcess = null;
+
+// Try to grab the Kerberos class
+try {
+ Kerberos = require('kerberos').Kerberos
+ // Authentication process for Mongo
+ MongoAuthProcess = require('kerberos').processes.MongoAuthProcess
+} catch(err) {}
+
+/**
+ * Creates a new SSPI authentication mechanism
+ * @class
+ * @return {SSPI} A cursor instance
+ */
+var SSPI = function() {
+ this.authStore = [];
+}
+
+/**
+ * Authenticate
+ * @method
+ * @param {{Server}|{ReplSet}|{Mongos}} server Topology the authentication method is being called on
+ * @param {Pool} pool Connection pool for this topology
+ * @param {string} db Name of the database
+ * @param {string} username Username
+ * @param {string} password Password
+ * @param {authResultCallback} callback The callback to return the result from the authentication
+ * @return {object}
+ */
+SSPI.prototype.auth = function(server, pool, db, username, password, options, callback) {
+ var self = this;
+ // We don't have the Kerberos library
+ if(Kerberos == null) return callback(new Error("Kerberos library is not installed"));
+ var gssapiServiceName = options['gssapiServiceName'] || 'mongodb';
+ // Get all the connections
+ var connections = pool.getAll();
+ // Total connections
+ var count = connections.length;
+ if(count == 0) return callback(null, null);
+
+ // Valid connections
+ var numberOfValidConnections = 0;
+ var credentialsValid = false;
+ var errorObject = null;
+
+ // For each connection we need to authenticate
+ while(connections.length > 0) {
+ // Execute MongoCR
+ var execute = function(connection) {
+ // Start Auth process for a connection
+ SSIPAuthenticate(username, password, gssapiServiceName, server, connection, function(err, r) {
+ // Adjust count
+ count = count - 1;
+
+ // If we have an error
+ if(err) {
+ errorObject = err;
+ } else if(r && typeof r == 'object' && r.result['$err']) {
+ errorObject = r.result;
+ } else if(r && typeof r == 'object' && r.result['errmsg']) {
+ errorObject = r.result;
+ } else {
+ credentialsValid = true;
+ numberOfValidConnections = numberOfValidConnections + 1;
+ }
+
+ // We have authenticated all connections
+ if(count == 0 && numberOfValidConnections > 0) {
+ // Store the auth details
+ addAuthSession(self.authStore, new AuthSession(db, username, password, options));
+ // Return correct authentication
+ callback(null, true);
+ } else if(count == 0) {
+ if(errorObject == null) errorObject = new MongoError(f("failed to authenticate using mongocr"));
+ callback(errorObject, false);
+ }
+ });
+ }
+
+ // Get the connection
+ execute(connections.shift());
+ }
+}
+
+var SSIPAuthenticate = function(username, password, gssapiServiceName, server, connection, callback) {
+ // Build Authentication command to send to MongoDB
+ var command = {
+ saslStart: 1
+ , mechanism: 'GSSAPI'
+ , payload: ''
+ , autoAuthorize: 1
+ };
+
+ // Create authenticator
+ var mongo_auth_process = new MongoAuthProcess(connection.host, connection.port, gssapiServiceName);
+
+ // Execute first sasl step
+ server.command("$external.$cmd"
+ , command
+ , { connection: connection }, function(err, r) {
+ if(err) return callback(err, false);
+ var doc = r.result;
+
+ mongo_auth_process.init(username, password, function(err) {
+ if(err) return callback(err);
+
+ mongo_auth_process.transition(doc.payload, function(err, payload) {
+ if(err) return callback(err);
+
+ // Perform the next step against mongod
+ var command = {
+ saslContinue: 1
+ , conversationId: doc.conversationId
+ , payload: payload
+ };
+
+ // Execute the command
+ server.command("$external.$cmd"
+ , command
+ , { connection: connection }, function(err, r) {
+ if(err) return callback(err, false);
+ var doc = r.result;
+
+ mongo_auth_process.transition(doc.payload, function(err, payload) {
+ if(err) return callback(err);
+
+ // Perform the next step against mongod
+ var command = {
+ saslContinue: 1
+ , conversationId: doc.conversationId
+ , payload: payload
+ };
+
+ // Execute the command
+ server.command("$external.$cmd"
+ , command
+ , { connection: connection }, function(err, r) {
+ if(err) return callback(err, false);
+ var doc = r.result;
+
+ mongo_auth_process.transition(doc.payload, function(err, payload) {
+ // Perform the next step against mongod
+ var command = {
+ saslContinue: 1
+ , conversationId: doc.conversationId
+ , payload: payload
+ };
+
+ // Execute the command
+ server.command("$external.$cmd"
+ , command
+ , { connection: connection }, function(err, r) {
+ if(err) return callback(err, false);
+ var doc = r.result;
+
+ if(doc.done) return callback(null, true);
+ callback(new Error("Authentication failed"), false);
+ });
+ });
+ });
+ });
+ });
+ });
+ });
+ });
+}
+
+// Add to store only if it does not exist
+var addAuthSession = function(authStore, session) {
+ var found = false;
+
+ for(var i = 0; i < authStore.length; i++) {
+ if(authStore[i].equal(session)) {
+ found = true;
+ break;
+ }
+ }
+
+ if(!found) authStore.push(session);
+}
+
+/**
+ * Re authenticate pool
+ * @method
+ * @param {{Server}|{ReplSet}|{Mongos}} server Topology the authentication method is being called on
+ * @param {Pool} pool Connection pool for this topology
+ * @param {authResultCallback} callback The callback to return the result from the authentication
+ * @return {object}
+ */
+SSPI.prototype.reauthenticate = function(server, pool, callback) {
+ var count = this.authStore.length;
+ if(count == 0) return callback(null, null);
+ // Iterate over all the auth details stored
+ for(var i = 0; i < this.authStore.length; i++) {
+ this.auth(server, pool, this.authStore[i].db, this.authStore[i].username, this.authStore[i].password, this.authStore[i].options, function(err, r) {
+ count = count - 1;
+ // Done re-authenticating
+ if(count == 0) {
+ callback(null, null);
+ }
+ });
+ }
+}
+
+/**
+ * This is a result from a authentication strategy
+ *
+ * @callback authResultCallback
+ * @param {error} error An error object. Set to null if no error present
+ * @param {boolean} result The result of the authentication process
+ */
+
+module.exports = SSPI;
\ No newline at end of file
diff --git a/server/node_modules/mongodb/node_modules/mongodb-core/lib/auth/x509.js b/server/node_modules/mongodb/node_modules/mongodb-core/lib/auth/x509.js
new file mode 100755
index 00000000..641990e4
--- /dev/null
+++ b/server/node_modules/mongodb/node_modules/mongodb-core/lib/auth/x509.js
@@ -0,0 +1,145 @@
+"use strict";
+
+var f = require('util').format
+ , crypto = require('crypto')
+ , MongoError = require('../error');
+
+var AuthSession = function(db, username, password) {
+ this.db = db;
+ this.username = username;
+ this.password = password;
+}
+
+AuthSession.prototype.equal = function(session) {
+ return session.db == this.db
+ && session.username == this.username
+ && session.password == this.password;
+}
+
+/**
+ * Creates a new X509 authentication mechanism
+ * @class
+ * @return {X509} A cursor instance
+ */
+var X509 = function() {
+ this.authStore = [];
+}
+
+/**
+ * Authenticate
+ * @method
+ * @param {{Server}|{ReplSet}|{Mongos}} server Topology the authentication method is being called on
+ * @param {Pool} pool Connection pool for this topology
+ * @param {string} db Name of the database
+ * @param {string} username Username
+ * @param {string} password Password
+ * @param {authResultCallback} callback The callback to return the result from the authentication
+ * @return {object}
+ */
+X509.prototype.auth = function(server, pool, db, username, password, callback) {
+ var self = this;
+ // Get all the connections
+ var connections = pool.getAll();
+ // Total connections
+ var count = connections.length;
+ if(count == 0) return callback(null, null);
+
+ // Valid connections
+ var numberOfValidConnections = 0;
+ var credentialsValid = false;
+ var errorObject = null;
+
+ // For each connection we need to authenticate
+ while(connections.length > 0) {
+ // Execute MongoCR
+ var execute = function(connection) {
+ // Let's start the sasl process
+ var command = {
+ authenticate: 1
+ , mechanism: 'MONGODB-X509'
+ , user: username
+ };
+
+ // Let's start the process
+ server.command("$external.$cmd"
+ , command
+ , { connection: connection }, function(err, r) {
+ // Adjust count
+ count = count - 1;
+
+ // If we have an error
+ if(err) {
+ errorObject = err;
+ } else if(r.result['$err']) {
+ errorObject = r.result;
+ } else if(r.result['errmsg']) {
+ errorObject = r.result;
+ } else {
+ credentialsValid = true;
+ numberOfValidConnections = numberOfValidConnections + 1;
+ }
+
+ // We have authenticated all connections
+ if(count == 0 && numberOfValidConnections > 0) {
+ // Store the auth details
+ addAuthSession(self.authStore, new AuthSession(db, username, password));
+ // Return correct authentication
+ callback(null, true);
+ } else if(count == 0) {
+ if(errorObject == null) errorObject = new MongoError(f("failed to authenticate using mongocr"));
+ callback(errorObject, false);
+ }
+ });
+ }
+
+ // Get the connection
+ execute(connections.shift());
+ }
+}
+
+// Add to store only if it does not exist
+var addAuthSession = function(authStore, session) {
+ var found = false;
+
+ for(var i = 0; i < authStore.length; i++) {
+ if(authStore[i].equal(session)) {
+ found = true;
+ break;
+ }
+ }
+
+ if(!found) authStore.push(session);
+}
+
+/**
+ * Re authenticate pool
+ * @method
+ * @param {{Server}|{ReplSet}|{Mongos}} server Topology the authentication method is being called on
+ * @param {Pool} pool Connection pool for this topology
+ * @param {authResultCallback} callback The callback to return the result from the authentication
+ * @return {object}
+ */
+X509.prototype.reauthenticate = function(server, pool, callback) {
+ var count = this.authStore.length;
+ if(count == 0) return callback(null, null);
+ // Iterate over all the auth details stored
+ for(var i = 0; i < this.authStore.length; i++) {
+ this.auth(server, pool, this.authStore[i].db, this.authStore[i].username, this.authStore[i].password, function(err, r) {
+ count = count - 1;
+ // Done re-authenticating
+ if(count == 0) {
+ callback(null, null);
+ }
+ });
+ }
+}
+
+/**
+ * This is a result from a authentication strategy
+ *
+ * @callback authResultCallback
+ * @param {error} error An error object. Set to null if no error present
+ * @param {boolean} result The result of the authentication process
+ */
+
+module.exports = X509;
\ No newline at end of file
diff --git a/server/node_modules/mongodb/node_modules/mongodb-core/lib/connection/commands.js b/server/node_modules/mongodb/node_modules/mongodb-core/lib/connection/commands.js
new file mode 100755
index 00000000..8529dd0a
--- /dev/null
+++ b/server/node_modules/mongodb/node_modules/mongodb-core/lib/connection/commands.js
@@ -0,0 +1,482 @@
+"use strict";
+
+var f = require('util').format
+ , Long = require('bson').Long
+ , setProperty = require('./utils').setProperty
+ , getProperty = require('./utils').getProperty
+ , getSingleProperty = require('./utils').getSingleProperty;
+
+// Incrementing request id
+var _requestId = 0;
+
+// Wire command operation ids
+var OP_QUERY = 2004;
+var OP_GETMORE = 2005;
+var OP_KILL_CURSORS = 2007;
+
+// Query flags
+var OPTS_NONE = 0;
+var OPTS_TAILABLE_CURSOR = 2;
+var OPTS_SLAVE = 4;
+var OPTS_OPLOG_REPLAY = 8;
+var OPTS_NO_CURSOR_TIMEOUT = 16;
+var OPTS_AWAIT_DATA = 32;
+var OPTS_EXHAUST = 64;
+var OPTS_PARTIAL = 128;
+
+// Response flags
+var CURSOR_NOT_FOUND = 0;
+var QUERY_FAILURE = 2;
+var SHARD_CONFIG_STALE = 4;
+var AWAIT_CAPABLE = 8;
+
+/**************************************************************
+ * QUERY
+ **************************************************************/
+var Query = function(bson, ns, query, options) {
+ var self = this;
+ // Basic options needed to be passed in
+ if(ns == null) throw new Error("ns must be specified for query");
+ if(query == null) throw new Error("query must be specified for query");
+
+ // Validate that we are not passing 0x00 in the colletion name
+ if(!!~ns.indexOf("\x00")) {
+ throw new Error("namespace cannot contain a null character");
+ }
+
+ // Basic options
+ this.bson = bson;
+ this.ns = ns;
+ this.query = query;
+
+ // Ensure empty options
+ this.options = options || {};
+
+ // Additional options
+ this.numberToSkip = options.numberToSkip || 0;
+ this.numberToReturn = options.numberToReturn || 0;
+ this.returnFieldSelector = options.returnFieldSelector || null;
+ this.requestId = _requestId++;
+
+ // Serialization option
+ this.serializeFunctions = typeof options.serializeFunctions == 'boolean' ? options.serializeFunctions : false;
+ this.maxBsonSize = options.maxBsonSize || 1024 * 1024 * 16;
+ this.checkKeys = typeof options.checkKeys == 'boolean' ? options.checkKeys : true;
+ this.batchSize = self.numberToReturn;
+
+ // Flags
+ this.tailable = false;
+ this.slaveOk = false;
+ this.oplogReply = false;
+ this.noCursorTimeout = false;
+ this.awaitData = false;
+ this.exhaust = false;
+ this.partial = false;
+}
+
+//
+// Assign a new request Id
+Query.prototype.incRequestId = function() {
+ this.requestId = _requestId++;
+}
+
+//
+// Uses a single allocated buffer for the process, avoiding multiple memory allocations
+Query.prototype.toBin = function() {
+ var self = this;
+ // Basic length
+ var length = 4
+ + Buffer.byteLength(self.ns)
+ + 1 + 4 + 4
+ + self.bson.calculateObjectSize(self.query, self.serializeFunctions, true)
+ + (4 * 4);
+
+ // Additional size for field selection
+ if(self.returnFieldSelector && Object.keys(self.returnFieldSelector).length > 0) {
+ length += self.bson.calculateObjectSize(self.returnFieldSelector, self.serializeFunctions, true);
+ }
+
+ // Allocate buffer for message
+ var _buffer = new Buffer(length);
+
+ // Set up the flags
+ var flags = 0;
+ if(this.tailable) flags |= OPTS_TAILABLE_CURSOR;
+ if(this.slaveOk) flags |= OPTS_SLAVE;
+ if(this.oplogReply) flags |= OPTS_OPLOG_REPLAY;
+ if(this.noCursorTimeout) flags |= OPTS_NO_CURSOR_TIMEOUT;
+ if(this.awaitData) flags |= OPTS_AWAIT_DATA;
+ if(this.exhaust) flags |= OPTS_EXHAUST;
+ if(this.partial) flags |= OPTS_PARTIAL;
+
+ // If batchSize is different to self.numberToReturn
+ if(self.batchSize != self.numberToReturn) self.numberToReturn = self.batchSize;
+
+ // Initial index
+ var index = 4;
+
+ // Write header information requestId
+ _buffer[index + 3] = (this.requestId >> 24) & 0xff;
+ _buffer[index + 2] = (this.requestId >> 16) & 0xff;
+ _buffer[index + 1] = (this.requestId >> 8) & 0xff;
+ _buffer[index] = (this.requestId) & 0xff;
+ index = index + 4;
+
+ // Write header information responseTo
+ _buffer[index + 3] = (0 >> 24) & 0xff;
+ _buffer[index + 2] = (0 >> 16) & 0xff;
+ _buffer[index + 1] = (0 >> 8) & 0xff;
+ _buffer[index] = (0) & 0xff;
+ index = index + 4;
+
+ // Write header information OP_QUERY
+ _buffer[index + 3] = (OP_QUERY >> 24) & 0xff;
+ _buffer[index + 2] = (OP_QUERY >> 16) & 0xff;
+ _buffer[index + 1] = (OP_QUERY >> 8) & 0xff;
+ _buffer[index] = (OP_QUERY) & 0xff;
+ index = index + 4;
+
+ // Write header information flags
+ _buffer[index + 3] = (flags >> 24) & 0xff;
+ _buffer[index + 2] = (flags >> 16) & 0xff;
+ _buffer[index + 1] = (flags >> 8) & 0xff;
+ _buffer[index] = (flags) & 0xff;
+ index = index + 4;
+
+ // Write collection name
+ index = index + _buffer.write(this.ns, index, 'utf8') + 1;
+ _buffer[index - 1] = 0;
+
+ // Write header information flags numberToSkip
+ _buffer[index + 3] = (this.numberToSkip >> 24) & 0xff;
+ _buffer[index + 2] = (this.numberToSkip >> 16) & 0xff;
+ _buffer[index + 1] = (this.numberToSkip >> 8) & 0xff;
+ _buffer[index] = (this.numberToSkip) & 0xff;
+ index = index + 4;
+
+ // Write header information flags numberToReturn
+ _buffer[index + 3] = (this.numberToReturn >> 24) & 0xff;
+ _buffer[index + 2] = (this.numberToReturn >> 16) & 0xff;
+ _buffer[index + 1] = (this.numberToReturn >> 8) & 0xff;
+ _buffer[index] = (this.numberToReturn) & 0xff;
+ index = index + 4;
+
+ // Serialize query
+ var queryLength = this.bson.serializeWithBufferAndIndex(this.query
+ , this.checkKeys
+ , _buffer, index
+ , this.serializeFunctions) - index + 1;
+
+ // Write header information flags queryLength
+ _buffer[index + 3] = (queryLength >> 24) & 0xff;
+ _buffer[index + 2] = (queryLength >> 16) & 0xff;
+ _buffer[index + 1] = (queryLength >> 8) & 0xff;
+ _buffer[index] = (queryLength) & 0xff;
+ index = index + 4;
+
+ // Add to the index
+ index = index - 4 + queryLength;
+ _buffer[index + 1] = 0x00;
+
+ // If we have field selectors
+ if(this.returnFieldSelector && Object.keys(this.returnFieldSelector).length > 0) {
+ var fieldSelectorLength = this.bson.serializeWithBufferAndIndex(this.returnFieldSelector
+ , this.checkKeys
+ , _buffer
+ , index
+ , this.serializeFunctions) - index + 1;
+
+ // Write header information flags fieldSelectorLength
+ _buffer[index + 3] = (fieldSelectorLength >> 24) & 0xff;
+ _buffer[index + 2] = (fieldSelectorLength >> 16) & 0xff;
+ _buffer[index + 1] = (fieldSelectorLength >> 8) & 0xff;
+ _buffer[index] = (fieldSelectorLength) & 0xff;
+ index = index + 4;
+
+ index = index - 4 + fieldSelectorLength;
+ _buffer[index + 1] = 0x00;
+ }
+
+ // Write total document length
+ _buffer[3] = (index >> 24) & 0xff;
+ _buffer[2] = (index >> 16) & 0xff;
+ _buffer[1] = (index >> 8) & 0xff;
+ _buffer[0] = (index) & 0xff;
+ // Return buffer
+ return _buffer;
+}
+
+Query.getRequestId = function() {
+ return ++_requestId;
+}
+
+/**************************************************************
+ * GETMORE
+ **************************************************************/
+var GetMore = function(bson, ns, cursorId, opts) {
+ opts = opts || {};
+ this.numberToReturn = opts.numberToReturn || 0;
+ this.requestId = _requestId++;
+ this.bson = bson;
+ this.ns = ns;
+ this.cursorId = cursorId;
+}
+
+//
+// Uses a single allocated buffer for the process, avoiding multiple memory allocations
+GetMore.prototype.toBin = function() {
+ var length = 4 + Buffer.byteLength(this.ns) + 1 + 4 + 8 + (4 * 4);
+ // Create command buffer
+ var index = 0;
+ // Allocate buffer
+ var _buffer = new Buffer(length);
+
+ // Write header information
+ // index = write32bit(index, _buffer, length);
+ _buffer[index + 3] = (length >> 24) & 0xff;
+ _buffer[index + 2] = (length >> 16) & 0xff;
+ _buffer[index + 1] = (length >> 8) & 0xff;
+ _buffer[index] = (length) & 0xff;
+ index = index + 4;
+
+ // index = write32bit(index, _buffer, requestId);
+ _buffer[index + 3] = (this.requestId >> 24) & 0xff;
+ _buffer[index + 2] = (this.requestId >> 16) & 0xff;
+ _buffer[index + 1] = (this.requestId >> 8) & 0xff;
+ _buffer[index] = (this.requestId) & 0xff;
+ index = index + 4;
+
+ // index = write32bit(index, _buffer, 0);
+ _buffer[index + 3] = (0 >> 24) & 0xff;
+ _buffer[index + 2] = (0 >> 16) & 0xff;
+ _buffer[index + 1] = (0 >> 8) & 0xff;
+ _buffer[index] = (0) & 0xff;
+ index = index + 4;
+
+ // index = write32bit(index, _buffer, OP_GETMORE);
+ _buffer[index + 3] = (OP_GETMORE >> 24) & 0xff;
+ _buffer[index + 2] = (OP_GETMORE >> 16) & 0xff;
+ _buffer[index + 1] = (OP_GETMORE >> 8) & 0xff;
+ _buffer[index] = (OP_GETMORE) & 0xff;
+ index = index + 4;
+
+ // index = write32bit(index, _buffer, 0);
+ _buffer[index + 3] = (0 >> 24) & 0xff;
+ _buffer[index + 2] = (0 >> 16) & 0xff;
+ _buffer[index + 1] = (0 >> 8) & 0xff;
+ _buffer[index] = (0) & 0xff;
+ index = index + 4;
+
+ // Write collection name
+ index = index + _buffer.write(this.ns, index, 'utf8') + 1;
+ _buffer[index - 1] = 0;
+
+ // Write batch size
+ // index = write32bit(index, _buffer, numberToReturn);
+ _buffer[index + 3] = (this.numberToReturn >> 24) & 0xff;
+ _buffer[index + 2] = (this.numberToReturn >> 16) & 0xff;
+ _buffer[index + 1] = (this.numberToReturn >> 8) & 0xff;
+ _buffer[index] = (this.numberToReturn) & 0xff;
+ index = index + 4;
+
+ // Write cursor id
+ // index = write32bit(index, _buffer, cursorId.getLowBits());
+ _buffer[index + 3] = (this.cursorId.getLowBits() >> 24) & 0xff;
+ _buffer[index + 2] = (this.cursorId.getLowBits() >> 16) & 0xff;
+ _buffer[index + 1] = (this.cursorId.getLowBits() >> 8) & 0xff;
+ _buffer[index] = (this.cursorId.getLowBits()) & 0xff;
+ index = index + 4;
+
+ // index = write32bit(index, _buffer, cursorId.getHighBits());
+ _buffer[index + 3] = (this.cursorId.getHighBits() >> 24) & 0xff;
+ _buffer[index + 2] = (this.cursorId.getHighBits() >> 16) & 0xff;
+ _buffer[index + 1] = (this.cursorId.getHighBits() >> 8) & 0xff;
+ _buffer[index] = (this.cursorId.getHighBits()) & 0xff;
+ index = index + 4;
+
+ // Return buffer
+ return _buffer;
+}
+
+/**************************************************************
+ * KILLCURSOR
+ **************************************************************/
+var KillCursor = function(bson, cursorIds) {
+ this.requestId = _requestId++;
+ this.cursorIds = cursorIds;
+}
+
+//
+// Uses a single allocated buffer for the process, avoiding multiple memory allocations
+KillCursor.prototype.toBin = function() {
+ var length = 4 + 4 + (4 * 4) + (this.cursorIds.length * 8);
+
+ // Create command buffer
+ var index = 0;
+ var _buffer = new Buffer(length);
+
+ // Write header information
+ // index = write32bit(index, _buffer, length);
+ _buffer[index + 3] = (length >> 24) & 0xff;
+ _buffer[index + 2] = (length >> 16) & 0xff;
+ _buffer[index + 1] = (length >> 8) & 0xff;
+ _buffer[index] = (length) & 0xff;
+ index = index + 4;
+
+ // index = write32bit(index, _buffer, requestId);
+ _buffer[index + 3] = (this.requestId >> 24) & 0xff;
+ _buffer[index + 2] = (this.requestId >> 16) & 0xff;
+ _buffer[index + 1] = (this.requestId >> 8) & 0xff;
+ _buffer[index] = (this.requestId) & 0xff;
+ index = index + 4;
+
+ // index = write32bit(index, _buffer, 0);
+ _buffer[index + 3] = (0 >> 24) & 0xff;
+ _buffer[index + 2] = (0 >> 16) & 0xff;
+ _buffer[index + 1] = (0 >> 8) & 0xff;
+ _buffer[index] = (0) & 0xff;
+ index = index + 4;
+
+ // index = write32bit(index, _buffer, OP_KILL_CURSORS);
+ _buffer[index + 3] = (OP_KILL_CURSORS >> 24) & 0xff;
+ _buffer[index + 2] = (OP_KILL_CURSORS >> 16) & 0xff;
+ _buffer[index + 1] = (OP_KILL_CURSORS >> 8) & 0xff;
+ _buffer[index] = (OP_KILL_CURSORS) & 0xff;
+ index = index + 4;
+
+ // index = write32bit(index, _buffer, 0);
+ _buffer[index + 3] = (0 >> 24) & 0xff;
+ _buffer[index + 2] = (0 >> 16) & 0xff;
+ _buffer[index + 1] = (0 >> 8) & 0xff;
+ _buffer[index] = (0) & 0xff;
+ index = index + 4;
+
+ // Write batch size
+ // index = write32bit(index, _buffer, this.cursorIds.length);
+ _buffer[index + 3] = (this.cursorIds.length >> 24) & 0xff;
+ _buffer[index + 2] = (this.cursorIds.length >> 16) & 0xff;
+ _buffer[index + 1] = (this.cursorIds.length >> 8) & 0xff;
+ _buffer[index] = (this.cursorIds.length) & 0xff;
+ index = index + 4;
+
+ // Write all the cursor ids into the array
+ for(var i = 0; i < this.cursorIds.length; i++) {
+ // Write cursor id
+ // index = write32bit(index, _buffer, cursorIds[i].getLowBits());
+ _buffer[index + 3] = (this.cursorIds[i].getLowBits() >> 24) & 0xff;
+ _buffer[index + 2] = (this.cursorIds[i].getLowBits() >> 16) & 0xff;
+ _buffer[index + 1] = (this.cursorIds[i].getLowBits() >> 8) & 0xff;
+ _buffer[index] = (this.cursorIds[i].getLowBits()) & 0xff;
+ index = index + 4;
+
+ // index = write32bit(index, _buffer, cursorIds[i].getHighBits());
+ _buffer[index + 3] = (this.cursorIds[i].getHighBits() >> 24) & 0xff;
+ _buffer[index + 2] = (this.cursorIds[i].getHighBits() >> 16) & 0xff;
+ _buffer[index + 1] = (this.cursorIds[i].getHighBits() >> 8) & 0xff;
+ _buffer[index] = (this.cursorIds[i].getHighBits()) & 0xff;
+ index = index + 4;
+ }
+
+ // Return buffer
+ return _buffer;
+}
+
+var Response = function(bson, data, opts) {
+ opts = opts || {promoteLongs: true};
+ this.parsed = false;
+
+ //
+ // Parse Header
+ //
+ this.index = 0;
+ this.raw = data;
+ this.data = data;
+ this.bson = bson;
+ this.opts = opts;
+
+ // Read the message length
+ this.length = data[this.index] | data[this.index + 1] << 8 | data[this.index + 2] << 16 | data[this.index + 3] << 24;
+ this.index = this.index + 4;
+
+ // Fetch the request id for this reply
+ this.requestId = data[this.index] | data[this.index + 1] << 8 | data[this.index + 2] << 16 | data[this.index + 3] << 24;
+ this.index = this.index + 4;
+
+ // Fetch the id of the request that triggered the response
+ this.responseTo = data[this.index] | data[this.index + 1] << 8 | data[this.index + 2] << 16 | data[this.index + 3] << 24;
+ this.index = this.index + 4;
+
+ // Skip op-code field
+ this.index = this.index + 4;
+
+ // Unpack flags
+ this.responseFlags = data[this.index] | data[this.index + 1] << 8 | data[this.index + 2] << 16 | data[this.index + 3] << 24;
+ this.index = this.index + 4;
+
+ // Unpack the cursor
+ var lowBits = data[this.index] | data[this.index + 1] << 8 | data[this.index + 2] << 16 | data[this.index + 3] << 24;
+ this.index = this.index + 4;
+ var highBits = data[this.index] | data[this.index + 1] << 8 | data[this.index + 2] << 16 | data[this.index + 3] << 24;
+ this.index = this.index + 4;
+ // Create long object
+ this.cursorId = new Long(lowBits, highBits);
+
+ // Unpack the starting from
+ this.startingFrom = data[this.index] | data[this.index + 1] << 8 | data[this.index + 2] << 16 | data[this.index + 3] << 24;
+ this.index = this.index + 4;
+
+ // Unpack the number of objects returned
+ this.numberReturned = data[this.index] | data[this.index + 1] << 8 | data[this.index + 2] << 16 | data[this.index + 3] << 24;
+ this.index = this.index + 4;
+
+ // Preallocate document array
+ this.documents = new Array(this.numberReturned);
+
+ // Flag values
+ this.cursorNotFound = (this.responseFlags & CURSOR_NOT_FOUND) != 0;
+ this.queryFailure = (this.responseFlags & QUERY_FAILURE) != 0;
+ this.shardConfigStale = (this.responseFlags & SHARD_CONFIG_STALE) != 0;
+ this.awaitCapable = (this.responseFlags & AWAIT_CAPABLE) != 0;
+ this.promoteLongs = typeof opts.promoteLongs == 'boolean' ? opts.promoteLongs : true;
+}
+
+Response.prototype.isParsed = function() {
+ return this.parsed;
+}
+
+Response.prototype.parse = function(options) {
+ // Don't parse again if not needed
+ if(this.parsed) return;
+ options = options || {};
+ // Allow the return of raw documents instead of parsing
+ var raw = options.raw || false;
+
+ //
+ // Parse Body
+ //
+ for(var i = 0; i < this.numberReturned; i++) {
+ var bsonSize = this.data[this.index] | this.data[this.index + 1] << 8 | this.data[this.index + 2] << 16 | this.data[this.index + 3] << 24;
+ // Parse options
+ var _options = {promoteLongs: this.opts.promoteLongs};
+
+ // If we have raw results specified slice the return document
+ if(raw) {
+ this.documents[i] = this.data.slice(this.index, this.index + bsonSize);
+ } else {
+ this.documents[i] = this.bson.deserialize(this.data.slice(this.index, this.index + bsonSize), _options);
+ }
+
+ // Adjust the index
+ this.index = this.index + bsonSize;
+ }
+
+ // Set parsed
+ this.parsed = true;
+}
+
+module.exports = {
+ Query: Query
+ , GetMore: GetMore
+ , Response: Response
+ , KillCursor: KillCursor
+}
\ No newline at end of file
diff --git a/server/node_modules/mongodb/node_modules/mongodb-core/lib/connection/connection.js b/server/node_modules/mongodb/node_modules/mongodb-core/lib/connection/connection.js
new file mode 100755
index 00000000..2a9a8d83
--- /dev/null
+++ b/server/node_modules/mongodb/node_modules/mongodb-core/lib/connection/connection.js
@@ -0,0 +1,454 @@
+"use strict";
+
+var inherits = require('util').inherits
+ , EventEmitter = require('events').EventEmitter
+ , net = require('net')
+ , tls = require('tls')
+ , f = require('util').format
+ , getSingleProperty = require('./utils').getSingleProperty
+ , debugOptions = require('./utils').debugOptions
+ , Response = require('./commands').Response
+ , MongoError = require('../error')
+ , Logger = require('./logger');
+
+var _id = 0;
+var debugFields = ['host', 'port', 'size', 'keepAlive', 'keepAliveInitialDelay', 'noDelay'
+ , 'connectionTimeout', 'socketTimeout', 'singleBufferSerializtion', 'ssl', 'ca', 'cert'
+ , 'rejectUnauthorized', 'promoteLongs'];
+
+/**
+ * Creates a new Connection instance
+ * @class
+ * @param {string} options.host The server host
+ * @param {number} options.port The server port
+ * @param {number} [options.size=5] Server connection pool size
+ * @param {boolean} [options.keepAlive=true] TCP Connection keep alive enabled
+ * @param {number} [options.keepAliveInitialDelay=0] Initial delay before TCP keep alive enabled
+ * @param {boolean} [options.noDelay=true] TCP Connection no delay
+ * @param {number} [options.connectionTimeout=0] TCP Connection timeout setting
+ * @param {number} [options.socketTimeout=0] TCP Socket timeout setting
+ * @param {boolean} [options.singleBufferSerializtion=true] Serialize into single buffer, trade of peak memory for serialization speed
+ * @param {boolean} [options.ssl=false] Use SSL for connection
+ * @param {Buffer} [options.ca] SSL Certificate store binary buffer
+ * @param {Buffer} [options.cert] SSL Certificate binary buffer
+ * @param {Buffer} [options.key] SSL Key file binary buffer
+ * @param {string} [options.passphrase] SSL Certificate pass phrase
+ * @param {boolean} [options.rejectUnauthorized=true] Reject unauthorized server certificates
+ * @param {boolean} [options.promoteLongs=true] Convert Long values from the db into Numbers if they fit into 53 bits
+ * @fires Connection#connect
+ * @fires Connection#close
+ * @fires Connection#error
+ * @fires Connection#timeout
+ * @fires Connection#parseError
+ * @return {Connection} A cursor instance
+ */
+var Connection = function(options) {
+ // Add event listener
+ EventEmitter.call(this);
+ // Set empty if no options passed
+ this.options = options || {};
+ // Identification information
+ this.id = _id++;
+ // Logger instance
+ this.logger = Logger('Connection', options);
+ // No bson parser passed in
+ if(!options.bson) throw new Error("must pass in valid bson parser");
+ // Get bson parser
+ this.bson = options.bson;
+ // Grouping tag used for debugging purposes
+ this.tag = options.tag;
+ // Message handler
+ this.messageHandler = options.messageHandler;
+
+ // Max BSON message size
+ this.maxBsonMessageSize = options.maxBsonMessageSize || (1024 * 1024 * 16 * 4);
+ // Debug information
+ if(this.logger.isDebug()) this.logger.debug(f('creating connection %s with options [%s]', this.id, JSON.stringify(debugOptions(debugFields, options))));
+
+ // Default options
+ this.port = options.port || 27017;
+ this.host = options.host || 'localhost';
+ this.keepAlive = typeof options.keepAlive == 'boolean' ? options.keepAlive : true;
+ this.keepAliveInitialDelay = options.keepAliveInitialDelay || 0;
+ this.noDelay = typeof options.noDelay == 'boolean' ? options.noDelay : true;
+ this.connectionTimeout = options.connectionTimeout || 0;
+ this.socketTimeout = options.socketTimeout || 0;
+
+ // Check if we have a domain socket
+ this.domainSocket = this.host.indexOf('\/') != -1;
+
+ // Serialize commands using function
+ this.singleBufferSerializtion = typeof options.singleBufferSerializtion == 'boolean' ? options.singleBufferSerializtion : true;
+ this.serializationFunction = this.singleBufferSerializtion ? 'toBinUnified' : 'toBin';
+
+ // SSL options
+ this.ca = options.ca || null;
+ this.cert = options.cert || null;
+ this.key = options.key || null;
+ this.passphrase = options.passphrase || null;
+ this.ssl = typeof options.ssl == 'boolean' ? options.ssl : false;
+ this.rejectUnauthorized = typeof options.rejectUnauthorized == 'boolean' ? options.rejectUnauthorized : true
+
+ // If ssl not enabled
+ if(!this.ssl) this.rejectUnauthorized = false;
+
+ // Response options
+ this.responseOptions = {
+ promoteLongs: typeof options.promoteLongs == 'boolean' ? options.promoteLongs : true
+ }
+
+ // Flushing
+ this.flushing = false;
+ this.queue = [];
+
+ // Internal state
+ this.connection = null;
+ this.writeStream = null;
+}
+
+inherits(Connection, EventEmitter);
+
+//
+// Connection handlers
+var errorHandler = function(self) {
+ return function(err) {
+ // Debug information
+ if(self.logger.isDebug()) self.logger.debug(f('connection %s for [%s:%s] errored out with [%s]', self.id, self.host, self.port, JSON.stringify(err)));
+ // Emit the error
+ if(self.listeners('error').length > 0) self.emit("error", MongoError.create(err), self);
+ }
+}
+
+var timeoutHandler = function(self) {
+ return function() {
+ // Debug information
+ if(self.logger.isDebug()) self.logger.debug(f('connection %s for [%s:%s] timed out', self.id, self.host, self.port));
+ // Emit timeout error
+ self.emit("timeout"
+ , MongoError.create(f("connection %s to %s:%s timed out", self.id, self.host, self.port))
+ , self);
+ }
+}
+
+var closeHandler = function(self) {
+ return function(hadError) {
+ // Debug information
+ if(self.logger.isDebug()) self.logger.debug(f('connection %s with for [%s:%s] closed', self.id, self.host, self.port));
+ // Emit close event
+ if(!hadError) {
+ self.emit("close"
+ , MongoError.create(f("connection %s to %s:%s closed", self.id, self.host, self.port))
+ , self);
+ }
+ }
+}
+
+var dataHandler = function(self) {
+ return function(data) {
+ // Parse until we are done with the data
+ while(data.length > 0) {
+ // If we still have bytes to read on the current message
+ if(self.bytesRead > 0 && self.sizeOfMessage > 0) {
+ // Calculate the amount of remaining bytes
+ var remainingBytesToRead = self.sizeOfMessage - self.bytesRead;
+ // Check if the current chunk contains the rest of the message
+ if(remainingBytesToRead > data.length) {
+ // Copy the new data into the exiting buffer (should have been allocated when we know the message size)
+ data.copy(self.buffer, self.bytesRead);
+ // Adjust the number of bytes read so it point to the correct index in the buffer
+ self.bytesRead = self.bytesRead + data.length;
+
+ // Reset state of buffer
+ data = new Buffer(0);
+ } else {
+ // Copy the missing part of the data into our current buffer
+ data.copy(self.buffer, self.bytesRead, 0, remainingBytesToRead);
+ // Slice the overflow into a new buffer that we will then re-parse
+ data = data.slice(remainingBytesToRead);
+
+ // Emit current complete message
+ try {
+ var emitBuffer = self.buffer;
+ // Reset state of buffer
+ self.buffer = null;
+ self.sizeOfMessage = 0;
+ self.bytesRead = 0;
+ self.stubBuffer = null;
+ // Emit the buffer
+ self.messageHandler(new Response(self.bson, emitBuffer, self.responseOptions), self);
+ } catch(err) {
+ var errorObject = {err:"socketHandler", trace:err, bin:self.buffer, parseState:{
+ sizeOfMessage:self.sizeOfMessage,
+ bytesRead:self.bytesRead,
+ stubBuffer:self.stubBuffer}};
+ // We got a parse Error fire it off then keep going
+ self.emit("parseError", errorObject, self);
+ }
+ }
+ } else {
+ // Stub buffer is kept in case we don't get enough bytes to determine the
+ // size of the message (< 4 bytes)
+ if(self.stubBuffer != null && self.stubBuffer.length > 0) {
+ // If we have enough bytes to determine the message size let's do it
+ if(self.stubBuffer.length + data.length > 4) {
+ // Prepad the data
+ var newData = new Buffer(self.stubBuffer.length + data.length);
+ self.stubBuffer.copy(newData, 0);
+ data.copy(newData, self.stubBuffer.length);
+ // Reassign for parsing
+ data = newData;
+
+ // Reset state of buffer
+ self.buffer = null;
+ self.sizeOfMessage = 0;
+ self.bytesRead = 0;
+ self.stubBuffer = null;
+
+ } else {
+
+ // Add the the bytes to the stub buffer
+ var newStubBuffer = new Buffer(self.stubBuffer.length + data.length);
+ // Copy existing stub buffer
+ self.stubBuffer.copy(newStubBuffer, 0);
+ // Copy missing part of the data
+ data.copy(newStubBuffer, self.stubBuffer.length);
+ // Exit parsing loop
+ data = new Buffer(0);
+ }
+ } else {
+ if(data.length > 4) {
+ // Retrieve the message size
+ // var sizeOfMessage = data.readUInt32LE(0);
+ var sizeOfMessage = data[0] | data[1] << 8 | data[2] << 16 | data[3] << 24;
+ // If we have a negative sizeOfMessage emit error and return
+ if(sizeOfMessage < 0 || sizeOfMessage > self.maxBsonMessageSize) {
+ var errorObject = {err:"socketHandler", trace:'', bin:self.buffer, parseState:{
+ sizeOfMessage: sizeOfMessage,
+ bytesRead: self.bytesRead,
+ stubBuffer: self.stubBuffer}};
+ // We got a parse Error fire it off then keep going
+ self.emit("parseError", errorObject, self);
+ return;
+ }
+
+ // Ensure that the size of message is larger than 0 and less than the max allowed
+ if(sizeOfMessage > 4 && sizeOfMessage < self.maxBsonMessageSize && sizeOfMessage > data.length) {
+ self.buffer = new Buffer(sizeOfMessage);
+ // Copy all the data into the buffer
+ data.copy(self.buffer, 0);
+ // Update bytes read
+ self.bytesRead = data.length;
+ // Update sizeOfMessage
+ self.sizeOfMessage = sizeOfMessage;
+ // Ensure stub buffer is null
+ self.stubBuffer = null;
+ // Exit parsing loop
+ data = new Buffer(0);
+
+ } else if(sizeOfMessage > 4 && sizeOfMessage < self.maxBsonMessageSize && sizeOfMessage == data.length) {
+ try {
+ var emitBuffer = data;
+ // Reset state of buffer
+ self.buffer = null;
+ self.sizeOfMessage = 0;
+ self.bytesRead = 0;
+ self.stubBuffer = null;
+ // Exit parsing loop
+ data = new Buffer(0);
+ // Emit the message
+ self.messageHandler(new Response(self.bson, emitBuffer, self.responseOptions), self);
+ } catch (err) {
+ var errorObject = {err:"socketHandler", trace:err, bin:self.buffer, parseState:{
+ sizeOfMessage:self.sizeOfMessage,
+ bytesRead:self.bytesRead,
+ stubBuffer:self.stubBuffer}};
+ // We got a parse Error fire it off then keep going
+ self.emit("parseError", errorObject, self);
+ }
+ } else if(sizeOfMessage <= 4 || sizeOfMessage > self.maxBsonMessageSize) {
+ var errorObject = {err:"socketHandler", trace:null, bin:data, parseState:{
+ sizeOfMessage:sizeOfMessage,
+ bytesRead:0,
+ buffer:null,
+ stubBuffer:null}};
+ // We got a parse Error fire it off then keep going
+ self.emit("parseError", errorObject, self);
+
+ // Clear out the state of the parser
+ self.buffer = null;
+ self.sizeOfMessage = 0;
+ self.bytesRead = 0;
+ self.stubBuffer = null;
+ // Exit parsing loop
+ data = new Buffer(0);
+ } else {
+ var emitBuffer = data.slice(0, sizeOfMessage);
+ // Reset state of buffer
+ self.buffer = null;
+ self.sizeOfMessage = 0;
+ self.bytesRead = 0;
+ self.stubBuffer = null;
+ // Copy rest of message
+ data = data.slice(sizeOfMessage);
+ // Emit the message
+ self.messageHandler(new Response(self.bson, emitBuffer, self.responseOptions), self);
+ }
+ } else {
+ // Create a buffer that contains the space for the non-complete message
+ self.stubBuffer = new Buffer(data.length)
+ // Copy the data to the stub buffer
+ data.copy(self.stubBuffer, 0);
+ // Exit parsing loop
+ data = new Buffer(0);
+ }
+ }
+ }
+ }
+ }
+}
+
+/**
+ * Connect
+ * @method
+ */
+Connection.prototype.connect = function(_options) {
+ var self = this;
+ _options = _options || {};
+ // Check if we are overriding the promoteLongs
+ if(typeof _options.promoteLongs == 'boolean') {
+ self.responseOptions.promoteLongs = _options.promoteLongs;
+ }
+
+ // Create new connection instance
+ self.connection = self.domainSocket
+ ? net.createConnection(self.host)
+ : net.createConnection(self.port, self.host);
+
+ // Set the options for the connection
+ self.connection.setKeepAlive(self.keepAlive, self.keepAliveInitialDelay);
+ self.connection.setTimeout(self.connectionTimeout);
+ self.connection.setNoDelay(self.noDelay);
+
+ // If we have ssl enabled
+ if(self.ssl) {
+ var sslOptions = {
+ socket: self.connection
+ , rejectUnauthorized: self.rejectUnauthorized
+ }
+
+ if(self.ca) sslOptions.ca = self.ca;
+ if(self.cert) sslOptions.cert = self.cert;
+ if(self.key) sslOptions.key = self.key;
+ if(self.passphrase) sslOptions.passphrase = self.passphrase;
+
+ // Attempt SSL connection
+ self.connection = tls.connect(self.port, self.host, sslOptions, function() {
+ // Error on auth or skip
+ if(self.connection.authorizationError && self.rejectUnauthorized) {
+ return self.emit("error", self.connection.authorizationError, self, {ssl:true});
+ }
+
+ // Set socket timeout instead of connection timeout
+ self.connection.setTimeout(self.socketTimeout);
+ // We are done emit connect
+ self.emit('connect', self);
+ });
+ } else {
+ self.connection.on('connect', function() {
+ // Set socket timeout instead of connection timeout
+ self.connection.setTimeout(self.socketTimeout);
+ // Emit connect event
+ self.emit('connect', self);
+ });
+ }
+
+ // Add handlers for events
+ self.connection.once('error', errorHandler(self));
+ self.connection.once('timeout', timeoutHandler(self));
+ self.connection.once('close', closeHandler(self));
+ self.connection.on('data', dataHandler(self));
+}
+
+/**
+ * Destroy connection
+ * @method
+ */
+Connection.prototype.destroy = function() {
+ if(this.connection) this.connection.destroy();
+}
+
+/**
+ * Write to connection
+ * @method
+ * @param {Command} command Command to write out need to implement toBin and toBinUnified
+ */
+Connection.prototype.write = function(buffer) {
+ // Debug log
+ if(this.logger.isDebug()) this.logger.debug(f('writing buffer [%s] to %s:%s', buffer.toString('hex'), this.host, this.port));
+ // Write out the command
+ this.connection.write(buffer, 'binary');
+}
+
+/**
+ * Return id of connection as a string
+ * @method
+ * @return {string}
+ */
+Connection.prototype.toString = function() {
+ return "" + this.id;
+}
+
+/**
+ * Return json object of connection
+ * @method
+ * @return {object}
+ */
+Connection.prototype.toJSON = function() {
+ return {id: this.id, host: this.host, port: this.port};
+}
+
+/**
+ * Is the connection connected
+ * @method
+ * @return {boolean}
+ */
+Connection.prototype.isConnected = function() {
+ return !this.connection.destroyed && this.connection.writable;
+}
+
+/**
+ * A server connect event, used to verify that the connection is up and running
+ *
+ * @event Connection#connect
+ * @type {Connection}
+ */
+
+/**
+ * The server connection closed, all pool connections closed
+ *
+ * @event Connection#close
+ * @type {Connection}
+ */
+
+/**
+ * The server connection caused an error, all pool connections closed
+ *
+ * @event Connection#error
+ * @type {Connection}
+ */
+
+/**
+ * The server connection timed out, all pool connections closed
+ *
+ * @event Connection#timeout
+ * @type {Connection}
+ */
+
+/**
+ * The driver experienced an invalid message, all pool connections closed
+ *
+ * @event Connection#parseError
+ * @type {Connection}
+ */
+
+module.exports = Connection;
diff --git a/server/node_modules/mongodb/node_modules/mongodb-core/lib/connection/logger.js b/server/node_modules/mongodb/node_modules/mongodb-core/lib/connection/logger.js
new file mode 100755
index 00000000..e50a0118
--- /dev/null
+++ b/server/node_modules/mongodb/node_modules/mongodb-core/lib/connection/logger.js
@@ -0,0 +1,193 @@
+"use strict";
+
+var f = require('util').format
+ , MongoError = require('../error');
+
+// Filters for classes
+var classFilters = {};
+var filteredClasses = {};
+var level = null;
+// Save the process id
+var pid = process.pid;
+// current logger
+var currentLogger = null;
+
+/**
+ * Creates a new Logger instance
+ * @class
+ * @param {string} className The Class name associated with the logging instance
+ * @param {object} [options=null] Optional settings.
+ * @param {Function} [options.logger=null] Custom logger function;
+ * @param {string} [options.loggerLevel=error] Override default global log level.
+ * @return {Logger} a Logger instance.
+ */
+var Logger = function(className, options) {
+ if(!(this instanceof Logger)) return new Logger(className, options);
+ options = options || {};
+
+ // Current reference
+ var self = this;
+ this.className = className;
+
+ // Current logger
+ if(currentLogger == null && options.logger) {
+ currentLogger = options.logger;
+ } else if(currentLogger == null) {
+ currentLogger = console.log;
+ }
+
+ // Set level of logging, default is error
+ if(level == null) {
+ level = options.loggerLevel || 'error';
+ }
+
+ // Add all class names
+ if(filteredClasses[this.className] == null) classFilters[this.className] = true;
+}
+
+/**
+ * Log a message at the debug level
+ * @method
+ * @param {string} message The message to log
+ * @param {object} object additional meta data to log
+ * @return {null}
+ */
+Logger.prototype.debug = function(message, object) {
+ if(this.isDebug()
+ && classFilters[this.className] && (filteredClasses[this.className] || Object.keys(filteredClasses).length == 0)) {
+ var dateTime = new Date().getTime();
+ var msg = f("[%s-%s:%s] %s %s", 'DEBUG', this.className, pid, dateTime, message);
+ var state = {
+ type: 'debug', message: message, className: this.className, pid: pid, date: dateTime
+ };
+ if(object) state.meta = object;
+ currentLogger(msg, state);
+ }
+}
+
+/**
+ * Log a message at the info level
+ * @method
+ * @param {string} message The message to log
+ * @param {object} object additional meta data to log
+ * @return {null}
+ */
+Logger.prototype.info = function(message, object) {
+ if(this.isInfo()
+ && classFilters[this.className] && (filteredClasses[this.className] || Object.keys(filteredClasses).length == 0)) {
+ var dateTime = new Date().getTime();
+ var msg = f("[%s-%s:%s] %s %s", 'INFO', this.className, pid, dateTime, message);
+ var state = {
+ type: 'info', message: message, className: this.className, pid: pid, date: dateTime
+ };
+ if(object) state.meta = object;
+ currentLogger(msg, state);
+ }
+},
+
+/**
+ * Log a message at the error level
+ * @method
+ * @param {string} message The message to log
+ * @param {object} object additional meta data to log
+ * @return {null}
+ */
+Logger.prototype.error = function(message, object) {
+ if(this.isError()
+ && classFilters[this.className] && (filteredClasses[this.className] || Object.keys(filteredClasses).length == 0)) {
+ var dateTime = new Date().getTime();
+ var msg = f("[%s-%s:%s] %s %s", 'ERROR', this.className, pid, dateTime, message);
+ var state = {
+ type: 'error', message: message, className: this.className, pid: pid, date: dateTime
+ };
+ if(object) state.meta = object;
+ currentLogger(msg, state);
+ }
+},
+
+/**
+ * Is the logger set at info level
+ * @method
+ * @return {boolean}
+ */
+Logger.prototype.isInfo = function() {
+ return level == 'info' || level == 'debug';
+},
+
+/**
+ * Is the logger set at error level
+ * @method
+ * @return {boolean}
+ */
+Logger.prototype.isError = function() {
+ return level == 'error' || level == 'info' || level == 'debug';
+},
+
+/**
+ * Is the logger set at debug level
+ * @method
+ * @return {boolean}
+ */
+Logger.prototype.isDebug = function() {
+ return level == 'debug';
+}
+
+/**
+ * Resets the logger to default settings, error and no filtered classes
+ * @method
+ * @return {null}
+ */
+Logger.reset = function() {
+ level = 'error';
+ filteredClasses = {};
+}
+
+/**
+ * Get the current logger function
+ * @method
+ * @return {function}
+ */
+Logger.currentLogger = function() {
+ return currentLogger;
+}
+
+/**
+ * Set the current logger function
+ * @method
+ * @param {function} logger Logger function.
+ * @return {null}
+ */
+Logger.setCurrentLogger = function(logger) {
+ if(typeof logger != 'function') throw new MongoError("current logger must be a function");
+ currentLogger = logger;
+}
+
+/**
+ * Set what classes to log.
+ * @method
+ * @param {string} type The type of filter (currently only class)
+ * @param {string[]} values The filters to apply
+ * @return {null}
+ */
+Logger.filter = function(type, values) {
+ if(type == 'class' && Array.isArray(values)) {
+ filteredClasses = {};
+
+ values.forEach(function(x) {
+ filteredClasses[x] = true;
+ });
+ }
+}
+
+/**
+ * Set the current log level
+ * @method
+ * @param {string} level Set current log level (debug, info, error)
+ * @return {null}
+ */
+Logger.setLevel = function(_level) {
+ if(_level != 'info' && _level != 'error' && _level != 'debug') throw new Error(f("%s is an illegal logging level", _level));
+ level = _level;
+}
+
+module.exports = Logger;
\ No newline at end of file
diff --git a/server/node_modules/mongodb/node_modules/mongodb-core/lib/connection/pool.js b/server/node_modules/mongodb/node_modules/mongodb-core/lib/connection/pool.js
new file mode 100755
index 00000000..7eb99844
--- /dev/null
+++ b/server/node_modules/mongodb/node_modules/mongodb-core/lib/connection/pool.js
@@ -0,0 +1,258 @@
+"use strict";
+
+var inherits = require('util').inherits
+ , EventEmitter = require('events').EventEmitter
+ , Connection = require('./connection')
+ , Query = require('./commands').Query
+ , Logger = require('./logger')
+ , f = require('util').format;
+
+var DISCONNECTED = 'disconnected';
+var CONNECTING = 'connecting';
+var CONNECTED = 'connected';
+var DESTROYED = 'destroyed';
+
+var _id = 0;
+
+/**
+ * Creates a new Pool instance
+ * @class
+ * @param {string} options.host The server host
+ * @param {number} options.port The server port
+ * @param {number} [options.size=5] Server connection pool size
+ * @param {boolean} [options.keepAlive=true] TCP Connection keep alive enabled
+ * @param {number} [options.keepAliveInitialDelay=0] Initial delay before TCP keep alive enabled
+ * @param {boolean} [options.noDelay=true] TCP Connection no delay
+ * @param {number} [options.connectionTimeout=0] TCP Connection timeout setting
+ * @param {number} [options.socketTimeout=0] TCP Socket timeout setting
+ * @param {boolean} [options.singleBufferSerializtion=true] Serialize into single buffer, trade of peak memory for serialization speed
+ * @param {boolean} [options.ssl=false] Use SSL for connection
+ * @param {Buffer} [options.ca] SSL Certificate store binary buffer
+ * @param {Buffer} [options.cert] SSL Certificate binary buffer
+ * @param {Buffer} [options.key] SSL Key file binary buffer
+ * @param {string} [options.passPhrase] SSL Certificate pass phrase
+ * @param {boolean} [options.rejectUnauthorized=false] Reject unauthorized server certificates
+ * @param {boolean} [options.promoteLongs=true] Convert Long values from the db into Numbers if they fit into 53 bits
+ * @fires Pool#connect
+ * @fires Pool#close
+ * @fires Pool#error
+ * @fires Pool#timeout
+ * @fires Pool#parseError
+ * @return {Pool} A cursor instance
+ */
+var Pool = function(options) {
+ var self = this;
+ // Add event listener
+ EventEmitter.call(this);
+ // Set empty if no options passed
+ this.options = options || {};
+ this.size = typeof options.size == 'number' ? options.size : 5;
+ // Message handler
+ this.messageHandler = options.messageHandler;
+ // No bson parser passed in
+ if(!options.bson) throw new Error("must pass in valid bson parser");
+ // Contains all connections
+ this.connections = [];
+ this.state = DISCONNECTED;
+ // Round robin index
+ this.index = 0;
+ this.dead = false;
+ // Logger instance
+ this.logger = Logger('Pool', options);
+ // Pool id
+ this.id = _id++;
+ // Grouping tag used for debugging purposes
+ this.tag = options.tag;
+}
+
+inherits(Pool, EventEmitter);
+
+var errorHandler = function(self) {
+ return function(err, connection) {
+ if(self.logger.isDebug()) self.logger.debug(f('pool [%s] errored out [%s] with connection [%s]', this.dead, JSON.stringify(err), JSON.stringify(connection)));
+ if(!self.dead) {
+ self.state = DISCONNECTED;
+ self.dead = true;
+ self.destroy();
+ self.emit('error', err, self);
+ }
+ }
+}
+
+var timeoutHandler = function(self) {
+ return function(err, connection) {
+ if(self.logger.isDebug()) self.logger.debug(f('pool [%s] timedout out [%s] with connection [%s]', this.dead, JSON.stringify(err), JSON.stringify(connection)));
+ if(!self.dead) {
+ self.state = DISCONNECTED;
+ self.dead = true;
+ self.destroy();
+ self.emit('timeout', err, self);
+ }
+ }
+}
+
+var closeHandler = function(self) {
+ return function(err, connection) {
+ if(self.logger.isDebug()) self.logger.debug(f('pool [%s] closed [%s] with connection [%s]', this.dead, JSON.stringify(err), JSON.stringify(connection)));
+ if(!self.dead) {
+ self.state = DISCONNECTED;
+ self.dead = true;
+ self.destroy();
+ self.emit('close', err, self);
+ }
+ }
+}
+
+var parseErrorHandler = function(self) {
+ return function(err, connection) {
+ if(self.logger.isDebug()) self.logger.debug(f('pool [%s] errored out [%s] with connection [%s]', this.dead, JSON.stringify(err), JSON.stringify(connection)));
+ if(!self.dead) {
+ self.state = DISCONNECTED;
+ self.dead = true;
+ self.destroy();
+ self.emit('parseError', err, self);
+ }
+ }
+}
+
+var connectHandler = function(self) {
+ return function(connection) {
+ self.connections.push(connection);
+ // We have connected to all servers
+ if(self.connections.length == self.size) {
+ self.state = CONNECTED;
+ // Done connecting
+ self.emit("connect", self);
+ }
+ }
+}
+
+/**
+ * Destroy pool
+ * @method
+ */
+Pool.prototype.destroy = function() {
+ this.state = DESTROYED;
+ // Set dead
+ this.dead = true;
+ // Destroy all the connections
+ this.connections.forEach(function(c) {
+ // Destroy all event emitters
+ ["close", "message", "error", "timeout", "parseError", "connect"].forEach(function(e) {
+ c.removeAllListeners(e);
+ });
+
+ // Destroy the connection
+ c.destroy();
+ });
+}
+
+/**
+ * Connect pool
+ * @method
+ */
+Pool.prototype.connect = function(_options) {
+ var self = this;
+ // Set to connecting
+ this.state = CONNECTING
+ // No dead
+ this.dead = false;
+ // Connect all sockets
+ for(var i = 0; i < this.size; i++) {
+ setTimeout(function() {
+ self.options.messageHandler = self.messageHandler;
+ var connection = new Connection(self.options);
+
+ // Add all handlers
+ connection.once('close', closeHandler(self));
+ connection.once('error', errorHandler(self));
+ connection.once('timeout', timeoutHandler(self));
+ connection.once('parseError', parseErrorHandler(self));
+ connection.on('connect', connectHandler(self));
+
+ // Start connection
+ connection.connect(_options);
+ }, 100);
+ }
+}
+
+/**
+ * Get a pool connection (round-robin)
+ * @method
+ * @return {Connection}
+ */
+Pool.prototype.get = function() {
+ // if(this.dead) return null;
+ var connection = this.connections[this.index++];
+ this.index = this.index % this.connections.length;
+ return connection;
+}
+
+/**
+ * Get all pool connections
+ * @method
+ * @return {array}
+ */
+Pool.prototype.getAll = function() {
+ return this.connections.slice(0);
+}
+
+/**
+ * Is the pool connected
+ * @method
+ * @return {boolean}
+ */
+Pool.prototype.isConnected = function() {
+ for(var i = 0; i < this.connections.length; i++) {
+ if(!this.connections[i].isConnected()) return false;
+ }
+
+ return this.state == CONNECTED;
+}
+
+/**
+ * Was the pool destroyed
+ * @method
+ * @return {boolean}
+ */
+Pool.prototype.isDestroyed = function() {
+ return this.state == DESTROYED;
+}
+
+
+/**
+ * A server connect event, used to verify that the connection is up and running
+ *
+ * @event Pool#connect
+ * @type {Pool}
+ */
+
+/**
+ * The server connection closed, all pool connections closed
+ *
+ * @event Pool#close
+ * @type {Pool}
+ */
+
+/**
+ * The server connection caused an error, all pool connections closed
+ *
+ * @event Pool#error
+ * @type {Pool}
+ */
+
+/**
+ * The server connection timed out, all pool connections closed
+ *
+ * @event Pool#timeout
+ * @type {Pool}
+ */
+
+/**
+ * The driver experienced an invalid message, all pool connections closed
+ *
+ * @event Pool#parseError
+ * @type {Pool}
+ */
+
+module.exports = Pool;
\ No newline at end of file
diff --git a/server/node_modules/mongodb/node_modules/mongodb-core/lib/connection/utils.js b/server/node_modules/mongodb/node_modules/mongodb-core/lib/connection/utils.js
new file mode 100755
index 00000000..7f0b89da
--- /dev/null
+++ b/server/node_modules/mongodb/node_modules/mongodb-core/lib/connection/utils.js
@@ -0,0 +1,77 @@
+"use strict";
+
+// Set property function
+var setProperty = function(obj, prop, flag, values) {
+ Object.defineProperty(obj, prop.name, {
+ enumerable:true,
+ set: function(value) {
+ if(typeof value != 'boolean') throw new Error(f("%s required a boolean", prop.name));
+ // Flip the bit to 1
+ if(value == true) values.flags |= flag;
+ // Flip the bit to 0 if it's set, otherwise ignore
+ if(value == false && (values.flags & flag) == flag) values.flags ^= flag;
+ prop.value = value;
+ }
+ , get: function() { return prop.value; }
+ });
+}
+
+// Set property function
+var getProperty = function(obj, propName, fieldName, values, func) {
+ Object.defineProperty(obj, propName, {
+ enumerable:true,
+ get: function() {
+ // Not parsed yet, parse it
+ if(values[fieldName] == null && obj.isParsed && !obj.isParsed()) {
+ obj.parse();
+ }
+
+ // Do we have a post processing function
+ if(typeof func == 'function') return func(values[fieldName]);
+ // Return raw value
+ return values[fieldName];
+ }
+ });
+}
+
+// Set simple property
+var getSingleProperty = function(obj, name, value) {
+ Object.defineProperty(obj, name, {
+ enumerable:true,
+ get: function() {
+ return value
+ }
+ });
+}
+
+// Shallow copy
+var copy = function(fObj, tObj) {
+ tObj = tObj || {};
+ for(var name in fObj) tObj[name] = fObj[name];
+ return tObj;
+}
+
+var debugOptions = function(debugFields, options) {
+ var finaloptions = {};
+ debugFields.forEach(function(n) {
+ finaloptions[n] = options[n];
+ });
+
+ return finaloptions;
+}
+
+/**
+ * @ignore
+ */
+var bindToCurrentDomain = function(callback) {
+ var domain = process.domain;
+ if(domain == null || callback == null) return callback;
+ return domain.bind(callback);
+}
+
+exports.setProperty = setProperty;
+exports.getProperty = getProperty;
+exports.getSingleProperty = getSingleProperty;
+exports.copy = copy;
+exports.bindToCurrentDomain = bindToCurrentDomain;
+exports.debugOptions = debugOptions;
\ No newline at end of file
diff --git a/server/node_modules/mongodb/node_modules/mongodb-core/lib/cursor.js b/server/node_modules/mongodb/node_modules/mongodb-core/lib/cursor.js
new file mode 100755
index 00000000..6ec2e4ae
--- /dev/null
+++ b/server/node_modules/mongodb/node_modules/mongodb-core/lib/cursor.js
@@ -0,0 +1,607 @@
+"use strict";
+
+var Long = require('bson').Long
+ , Logger = require('./connection/logger')
+ , MongoError = require('./error')
+ , f = require('util').format;
+
+/**
+ * This is a cursor results callback
+ *
+ * @callback resultCallback
+ * @param {error} error An error object. Set to null if no error present
+ * @param {object} document
+ */
+
+/**
+ * @fileOverview The **Cursor** class is an internal class that embodies a cursor on MongoDB
+ * allowing for iteration over the results returned from the underlying query.
+ *
+ * **CURSORS Cannot directly be instantiated**
+ * @example
+ * var Server = require('mongodb-core').Server
+ * , ReadPreference = require('mongodb-core').ReadPreference
+ * , assert = require('assert');
+ *
+ * var server = new Server({host: 'localhost', port: 27017});
+ * // Wait for the connection event
+ * server.on('connect', function(server) {
+ * assert.equal(null, err);
+ *
+ * // Execute the write
+ * var cursor = _server.cursor('integration_tests.inserts_example4', {
+ * find: 'integration_tests.example4'
+ * , query: {a:1}
+ * }, {
+ * readPreference: new ReadPreference('secondary');
+ * });
+ *
+ * // Get the first document
+ * cursor.next(function(err, doc) {
+ * assert.equal(null, err);
+ * server.destroy();
+ * });
+ * });
+ *
+ * // Start connecting
+ * server.connect();
+ */
+
+/**
+ * Creates a new Cursor, not to be used directly
+ * @class
+ * @param {object} bson An instance of the BSON parser
+ * @param {string} ns The MongoDB fully qualified namespace (ex: db1.collection1)
+ * @param {{object}|Long} cmd The selector (can be a command or a cursorId)
+ * @param {object} [options=null] Optional settings.
+ * @param {object} [options.batchSize=1000] Batchsize for the operation
+ * @param {array} [options.documents=[]] Initial documents list for cursor
+ * @param {object} [options.transforms=null] Transform methods for the cursor results
+ * @param {function} [options.transforms.query] Transform the value returned from the initial query
+ * @param {function} [options.transforms.doc] Transform each document returned from Cursor.prototype.next
+ * @param {object} topology The server topology instance.
+ * @param {object} topologyOptions The server topology options.
+ * @return {Cursor} A cursor instance
+ * @property {number} cursorBatchSize The current cursorBatchSize for the cursor
+ * @property {number} cursorLimit The current cursorLimit for the cursor
+ * @property {number} cursorSkip The current cursorSkip for the cursor
+ */
+var Cursor = function(bson, ns, cmd, options, topology, topologyOptions) {
+ options = options || {};
+ // Cursor reference
+ var self = this;
+ // Initial query
+ var query = null;
+
+ // Cursor connection
+ this.connection = null;
+ // Cursor server
+ this.server = null;
+
+ // Do we have a not connected handler
+ this.disconnectHandler = options.disconnectHandler;
+
+ // Set local values
+ this.bson = bson;
+ this.ns = ns;
+ this.cmd = cmd;
+ this.options = options;
+ this.topology = topology;
+
+ // All internal state
+ this.cursorState = {
+ cursorId: null
+ , documents: options.documents || []
+ , cursorIndex: 0
+ , dead: false
+ , killed: false
+ , init: false
+ , notified: false
+ , limit: options.limit || cmd.limit || 0
+ , skip: options.skip || cmd.skip || 0
+ , batchSize: options.batchSize || cmd.batchSize || 1000
+ , currentLimit: 0
+ // Result field name if not a cursor (contains the array of results)
+ , transforms: options.transforms
+ }
+
+ // Callback controller
+ this.callbacks = null;
+
+ // Logger
+ this.logger = Logger('Cursor', options);
+
+ //
+ // Did we pass in a cursor id
+ if(typeof cmd == 'number') {
+ this.cursorState.cursorId = Long.fromNumber(cmd);
+ } else if(cmd instanceof Long) {
+ this.cursorState.cursorId = cmd;
+ }
+}
+
+Cursor.prototype.setCursorBatchSize = function(value) {
+ this.cursorState.batchSize = value;
+}
+
+Cursor.prototype.cursorBatchSize = function() {
+ return this.cursorState.batchSize;
+}
+
+Cursor.prototype.setCursorLimit = function(value) {
+ this.cursorState.limit = value;
+}
+
+Cursor.prototype.cursorLimit = function() {
+ return this.cursorState.limit;
+}
+
+Cursor.prototype.setCursorSkip = function(value) {
+ this.cursorState.skip = value;
+}
+
+Cursor.prototype.cursorSkip = function() {
+ return this.cursorState.skip;
+}
+
+//
+// Execute getMore command
+var execGetMore = function(self, callback) {
+ if(self.logger.isDebug()) self.logger.debug(f("schedule getMore call for query [%s]", JSON.stringify(self.query)))
+ // Determine if it's a raw query
+ var raw = self.options.raw || self.cmd.raw;
+ // We have a wire protocol handler
+ self.server.wireProtocolHandler.getMore(self.bson, self.ns, self.cursorState, self.cursorState.batchSize, raw, self.connection, self.callbacks, self.options, callback);
+}
+
+//
+// Execute the first query
+var execInitialQuery = function(self, query, cmd, options, cursorState, connection, logger, callbacks, callback) {
+ if(logger.isDebug()) {
+ logger.debug(f("issue initial query [%s] with flags [%s]"
+ , JSON.stringify(cmd)
+ , JSON.stringify(query)));
+ }
+
+ var queryCallback = function(err, result) {
+ if(err) return callback(err);
+
+ if (result.queryFailure) {
+ return callback(MongoError.create(result.documents[0]), null);
+ }
+
+ // Check if we have a command cursor
+ if(Array.isArray(result.documents) && result.documents.length == 1 && !cmd.find) {
+ if(result.documents[0]['$err']
+ || result.documents[0]['errmsg']) {
+ return callback(MongoError.create(result.documents[0]), null);
+ }
+
+ if(result.documents[0].cursor != null
+ && typeof result.documents[0].cursor != 'string') {
+ var id = result.documents[0].cursor.id;
+ // If we have a namespace change set the new namespace for getmores
+ if(result.documents[0].cursor.ns) {
+ self.ns = result.documents[0].cursor.ns;
+ }
+ // Promote id to long if needed
+ cursorState.cursorId = typeof id == 'number' ? Long.fromNumber(id) : id;
+ // If we have a firstBatch set it
+ if(Array.isArray(result.documents[0].cursor.firstBatch)) {
+ cursorState.documents = result.documents[0].cursor.firstBatch;//.reverse();
+ }
+
+ // Return after processing command cursor
+ return callback(null, null);
+ }
+
+ if(Array.isArray(result.documents[0].result)) {
+ cursorState.documents = result.documents[0].result;
+ cursorState.cursorId = Long.ZERO;
+ return callback(null, null);
+ }
+ }
+
+ // Otherwise fall back to regular find path
+ cursorState.cursorId = result.cursorId;
+ cursorState.documents = result.documents;
+
+ // Transform the results with passed in transformation method if provided
+ if(cursorState.transforms && typeof cursorState.transforms.query == 'function') {
+ cursorState.documents = cursorState.transforms.query(result);
+ }
+
+ // Return callback
+ callback(null, null);
+ }
+
+ // If we have a raw query decorate the function
+ if(options.raw || cmd.raw) {
+ queryCallback.raw = options.raw || cmd.raw;
+ }
+
+ // Set up callback
+ callbacks.register(query.requestId, queryCallback);
+
+ // Write the initial command out
+ connection.write(query.toBin());
+}
+
+//
+// Handle callback (including any exceptions thrown)
+var handleCallback = function(callback, err, result) {
+ try {
+ callback(err, result);
+ } catch(err) {
+ process.nextTick(function() {
+ throw err;
+ });
+ }
+}
+
+/**
+ * Clone the cursor
+ * @method
+ * @return {Cursor}
+ */
+Cursor.prototype.clone = function() {
+ return this.topology.cursor(this.ns, this.cmd, this.options);
+}
+
+/**
+ * Checks if the cursor is dead
+ * @method
+ * @return {boolean} A boolean signifying if the cursor is dead or not
+ */
+Cursor.prototype.isDead = function() {
+ return this.cursorState.dead == true;
+}
+
+/**
+ * Checks if the cursor was killed by the application
+ * @method
+ * @return {boolean} A boolean signifying if the cursor was killed by the application
+ */
+Cursor.prototype.isKilled = function() {
+ return this.cursorState.killed == true;
+}
+
+/**
+ * Checks if the cursor notified it's caller about it's death
+ * @method
+ * @return {boolean} A boolean signifying if the cursor notified the callback
+ */
+Cursor.prototype.isNotified = function() {
+ return this.cursorState.notified == true;
+}
+
+/**
+ * Returns current buffered documents length
+ * @method
+ * @return {number} The number of items in the buffered documents
+ */
+Cursor.prototype.bufferedCount = function() {
+ return this.cursorState.documents.length - this.cursorState.cursorIndex;
+}
+
+/**
+ * Returns current buffered documents
+ * @method
+ * @return {Array} An array of buffered documents
+ */
+Cursor.prototype.readBufferedDocuments = function(number) {
+ var unreadDocumentsLength = this.cursorState.documents.length - this.cursorState.cursorIndex;
+ var length = number < unreadDocumentsLength ? number : unreadDocumentsLength;
+ var elements = this.cursorState.documents.slice(this.cursorState.cursorIndex, this.cursorState.cursorIndex + length);
+ this.cursorState.currentLimit = this.cursorState.currentLimit + length;
+ this.cursorState.cursorIndex = this.cursorState.cursorIndex + length;
+
+ // Transform the doc with passed in transformation method if provided
+ if(this.cursorState.transforms && typeof this.cursorState.transforms.doc == 'function') {
+ // Transform all the elements
+ for(var i = 0; i < elements.length; i++) {
+ elements[i] = this.cursorState.transforms.doc(elements[i]);
+ }
+ }
+
+ // Return elements
+ return elements;
+}
+
+/**
+ * Kill the cursor
+ * @method
+ * @param {resultCallback} callback A callback function
+ */
+Cursor.prototype.kill = function(callback) {
+ // Set cursor to dead
+ this.cursorState.dead = true;
+ this.cursorState.killed = true;
+ // Remove documents
+ this.cursorState.documents = [];
+
+ // If no cursor id just return
+ if(this.cursorState.cursorId == null || this.cursorState.cursorId.isZero() || this.cursorState.init == false) {
+ if(callback) callback(null, null);
+ return;
+ }
+
+ // Execute command
+ this.server.wireProtocolHandler.killCursor(this.bson, this.cursorState.cursorId, this.connection, callback);
+}
+
+/**
+ * Resets the cursor
+ * @method
+ * @return {null}
+ */
+Cursor.prototype.rewind = function() {
+ if(this.cursorState.init) {
+ if(!this.cursorState.dead) {
+ this.kill();
+ }
+
+ this.cursorState.currentLimit = 0;
+ this.cursorState.init = false;
+ this.cursorState.dead = false;
+ this.cursorState.killed = false;
+ this.cursorState.notified = false;
+ this.cursorState.documents = [];
+ this.cursorState.cursorId = null;
+ this.cursorState.cursorIndex = 0;
+ }
+}
+
+/**
+ * Validate if the connection is dead and return error
+ */
+var isConnectionDead = function(self, callback) {
+ if(self.connection
+ && !self.connection.isConnected()) {
+ self.cursorState.notified = true;
+ self.cursorState.killed = true;
+ self.cursorState.documents = [];
+ self.cursorState.cursorIndex = 0;
+ callback(MongoError.create(f('connection to host %s:%s was destroyed', self.connection.host, self.connection.port)))
+ return true;
+ }
+
+ return false;
+}
+
+/**
+ * Validate if the cursor is dead but was not explicitly killed by user
+ */
+var isCursorDeadButNotkilled = function(self, callback) {
+ // Cursor is dead but not marked killed, return null
+ if(self.cursorState.dead && !self.cursorState.killed) {
+ self.cursorState.notified = true;
+ self.cursorState.killed = true;
+ self.cursorState.documents = [];
+ self.cursorState.cursorIndex = 0;
+ handleCallback(callback, null, null);
+ return true;
+ }
+
+ return false;
+}
+
+/**
+ * Validate if the cursor is dead and was killed by user
+ */
+var isCursorDeadAndKilled = function(self, callback) {
+ if(self.cursorState.dead && self.cursorState.killed) {
+ handleCallback(callback, MongoError.create("cursor is dead"));
+ return true;
+ }
+
+ return false;
+}
+
+/**
+ * Validate if the cursor was killed by the user
+ */
+var isCursorKilled = function(self, callback) {
+ if(self.cursorState.killed) {
+ self.cursorState.notified = true;
+ self.cursorState.documents = [];
+ self.cursorState.cursorIndex = 0;
+ handleCallback(callback, null, null);
+ return true;
+ }
+
+ return false;
+}
+
+/**
+ * Mark cursor as being dead and notified
+ */
+var setCursorDeadAndNotified = function(self, callback) {
+ self.cursorState.dead = true;
+ self.cursorState.notified = true;
+ self.cursorState.documents = [];
+ self.cursorState.cursorIndex = 0;
+ handleCallback(callback, null, null);
+}
+
+/**
+ * Mark cursor as being notified
+ */
+var setCursorNotified = function(self, callback) {
+ self.cursorState.notified = true;
+ self.cursorState.documents = [];
+ self.cursorState.cursorIndex = 0;
+ handleCallback(callback, null, null);
+}
+
+/**
+ * Retrieve the next document from the cursor
+ * @method
+ * @param {resultCallback} callback A callback function
+ */
+Cursor.prototype.next = function(callback) {
+ var self = this;
+ // We have notified about it
+ if(self.cursorState.notified) return;
+
+ // Cursor is killed return null
+ if(isCursorKilled(self, callback)) return;
+
+ // Cursor is dead but not marked killed, return null
+ if(isCursorDeadButNotkilled(self, callback)) return;
+
+ // We have a dead and killed cursor, attempting to call next should error
+ if(isCursorDeadAndKilled(self, callback)) return;
+
+ // We have just started the cursor
+ if(!self.cursorState.init) {
+ // Topology is not connected, save the call in the provided store to be
+ // Executed at some point when the handler deems it's reconnected
+ if(!self.topology.isConnected(self.options) && self.disconnectHandler != null) {
+ return self.disconnectHandler.addObjectAndMethod('cursor', self, 'next', [callback], callback);
+ }
+
+ try {
+ // Get a server
+ self.server = self.topology.getServer(self.options);
+ // Get a connection
+ self.connection = self.server.getConnection();
+ // Get the callbacks
+ self.callbacks = self.server.getCallbacks();
+ } catch(err) {
+ return callback(err);
+ }
+
+ // Set as init
+ self.cursorState.init = true;
+ // Get the right wire protocol command
+ this.query = self.server.wireProtocolHandler.command(self.bson, self.ns, self.cmd, self.cursorState, self.topology, self.options);
+ }
+
+ // Process exhaust messages
+ var processExhaustMessages = function(err, result) {
+ if(err) {
+ self.cursorState.dead = true;
+ self.callbacks.unregister(self.query.requestId);
+ return callback(err);
+ }
+
+ // Concatenate all the documents
+ self.cursorState.documents = self.cursorState.documents.concat(result.documents);
+
+ // If we have no documents left
+ if(Long.ZERO.equals(result.cursorId)) {
+ self.cursorState.cursorId = Long.ZERO;
+ self.callbacks.unregister(self.query.requestId);
+ return self.next(callback);
+ }
+
+ // Set up next listener
+ self.callbacks.register(result.requestId, processExhaustMessages)
+
+ // Initial result
+ if(self.cursorState.cursorId == null) {
+ self.cursorState.cursorId = result.cursorId;
+ self.next(callback);
+ }
+ }
+
+ // If we have exhaust
+ if(self.cmd.exhaust && self.cursorState.cursorId == null) {
+ // Handle all the exhaust responses
+ self.callbacks.register(self.query.requestId, processExhaustMessages);
+ // Write the initial command out
+ return self.connection.write(self.query.toBin());
+ } else if(self.cmd.exhaust && self.cursorState.cursorIndex < self.cursorState.documents.length) {
+ return handleCallback(callback, null, self.cursorState.documents[self.cursorState.cursorIndex++]);
+ } else if(self.cmd.exhaust && Long.ZERO.equals(self.cursorState.cursorId)) {
+ self.callbacks.unregister(self.query.requestId);
+ return setCursorNotified(self, callback);
+ } else if(self.cmd.exhaust) {
+ return setTimeout(function() {
+ if(Long.ZERO.equals(self.cursorState.cursorId)) return;
+ self.next(callback);
+ }, 1);
+ }
+
+ // If we don't have a cursorId execute the first query
+ if(self.cursorState.cursorId == null) {
+ // Check if connection is dead and return if not possible to
+ // execute the query against the db
+ if(isConnectionDead(self, callback)) return;
+
+ // query, cmd, options, cursorState, callback
+ execInitialQuery(self, self.query, self.cmd, self.options, self.cursorState, self.connection, self.logger, self.callbacks, function(err, r) {
+ if(err) return handleCallback(callback, err, null);
+ if(self.cursorState.documents.length == 0 && !self.cmd.tailable && !self.cmd.awaitData) {
+ return setCursorNotified(self, callback);
+ }
+
+ self.next(callback);
+ });
+ } else if(self.cursorState.limit > 0 && self.cursorState.currentLimit >= self.cursorState.limit) {
+ return setCursorDeadAndNotified(self, callback);
+ } else if(self.cursorState.cursorIndex == self.cursorState.documents.length
+ && !Long.ZERO.equals(self.cursorState.cursorId)) {
+ // Ensure an empty cursor state
+ self.cursorState.documents = [];
+ self.cursorState.cursorIndex = 0;
+
+ // Check if connection is dead and return if not possible to
+ // execute a getmore on this connection
+ if(isConnectionDead(self, callback)) return;
+
+ // Execute the next get more
+ execGetMore(self, function(err, doc) {
+ if(err) return handleCallback(callback, err);
+ if(self.cursorState.documents.length == 0 && Long.ZERO.equals(self.cursorState.cursorId)) self.cursorState.dead = true;
+
+ // Tailable cursor getMore result, notify owner about it
+ // No attempt is made here to retry, this is left to the user of the
+ // core module to handle to keep core simple
+ if(self.cursorState.documents.length == 0 && self.cmd.tailable) {
+ return handleCallback(callback, MongoError.create({
+ message: "No more documents in tailed cursor"
+ , tailable: self.cmd.tailable
+ , awaitData: self.cmd.awaitData
+ }));
+ }
+
+ if(self.cursorState.limit > 0 && self.cursorState.currentLimit >= self.cursorState.limit) {
+ return setCursorDeadAndNotified(self, callback);
+ }
+
+ self.next(callback);
+ });
+ } else if(self.cursorState.documents.length == self.cursorState.cursorIndex
+ && self.cmd.tailable) {
+ return handleCallback(callback, MongoError.create({
+ message: "No more documents in tailed cursor"
+ , tailable: self.cmd.tailable
+ , awaitData: self.cmd.awaitData
+ }));
+ } else if(self.cursorState.documents.length == self.cursorState.cursorIndex
+ && Long.ZERO.equals(self.cursorState.cursorId)) {
+ setCursorDeadAndNotified(self, callback);
+ } else {
+ if(self.cursorState.limit > 0 && self.cursorState.currentLimit >= self.cursorState.limit) {
+ return setCursorDeadAndNotified(self, callback);
+ }
+
+ // Increment the current cursor limit
+ self.cursorState.currentLimit += 1;
+
+ // Get the document
+ var doc = self.cursorState.documents[self.cursorState.cursorIndex++];
+
+ // Transform the doc with passed in transformation method if provided
+ if(self.cursorState.transforms && typeof self.cursorState.transforms.doc == 'function') {
+ doc = self.cursorState.transforms.doc(doc);
+ }
+
+ // Return the document
+ handleCallback(callback, null, doc);
+ }
+}
+
+module.exports = Cursor;
diff --git a/server/node_modules/mongodb/node_modules/mongodb-core/lib/error.js b/server/node_modules/mongodb/node_modules/mongodb-core/lib/error.js
new file mode 100755
index 00000000..8c1f84ec
--- /dev/null
+++ b/server/node_modules/mongodb/node_modules/mongodb-core/lib/error.js
@@ -0,0 +1,44 @@
+"use strict";
+
+/**
+ * Creates a new MongoError
+ * @class
+ * @augments Error
+ * @param {string} message The error message
+ * @return {MongoError} A cursor instance
+ */
+function MongoError(message) {
+ this.name = 'MongoError';
+ this.message = message;
+ this.stack = (new Error()).stack;
+}
+
+/**
+ * Creates a new MongoError object
+ * @class
+ * @param {object} options The error options
+ * @return {MongoError} A cursor instance
+ */
+MongoError.create = function(options) {
+ var err = null;
+
+ if(options instanceof Error) {
+ err = new MongoError(options.message);
+ err.stack = options.stack;
+ } else if(typeof options == 'string') {
+ err = new MongoError(options);
+ } else {
+ err = new MongoError(options.message || options.errmsg || "n/a");
+ // Other options
+ for(var name in options) {
+ err[name] = options[name];
+ }
+ }
+
+ return err;
+}
+
+// Extend JavaScript error
+MongoError.prototype = new Error;
+
+module.exports = MongoError;
diff --git a/server/node_modules/mongodb/node_modules/mongodb-core/lib/tools/smoke_plugin.js b/server/node_modules/mongodb/node_modules/mongodb-core/lib/tools/smoke_plugin.js
new file mode 100755
index 00000000..dcceda4b
--- /dev/null
+++ b/server/node_modules/mongodb/node_modules/mongodb-core/lib/tools/smoke_plugin.js
@@ -0,0 +1,59 @@
+var fs = require('fs');
+
+/* Note: because this plugin uses process.on('uncaughtException'), only one
+ * of these can exist at any given time. This plugin and anything else that
+ * uses process.on('uncaughtException') will conflict. */
+exports.attachToRunner = function(runner, outputFile) {
+ var smokeOutput = { results : [] };
+ var runningTests = {};
+
+ var integraPlugin = {
+ beforeTest: function(test, callback) {
+ test.startTime = Date.now();
+ runningTests[test.name] = test;
+ callback();
+ },
+ afterTest: function(test, callback) {
+ smokeOutput.results.push({
+ status: test.status,
+ start: test.startTime,
+ end: Date.now(),
+ test_file: test.name,
+ exit_code: 0,
+ url: ""
+ });
+ delete runningTests[test.name];
+ callback();
+ },
+ beforeExit: function(obj, callback) {
+ fs.writeFile(outputFile, JSON.stringify(smokeOutput), function() {
+ callback();
+ });
+ }
+ };
+
+ // In case of exception, make sure we write file
+ process.on('uncaughtException', function(err) {
+ // Mark all currently running tests as failed
+ for (var testName in runningTests) {
+ smokeOutput.results.push({
+ status: "fail",
+ start: runningTests[testName].startTime,
+ end: Date.now(),
+ test_file: testName,
+ exit_code: 0,
+ url: ""
+ });
+ }
+
+ // write file
+ fs.writeFileSync(outputFile, JSON.stringify(smokeOutput));
+
+ // Standard NodeJS uncaught exception handler
+ console.error(err.stack);
+ process.exit(1);
+ });
+
+ runner.plugin(integraPlugin);
+ return integraPlugin;
+};
diff --git a/server/node_modules/mongodb/node_modules/mongodb-core/lib/topologies/command_result.js b/server/node_modules/mongodb/node_modules/mongodb-core/lib/topologies/command_result.js
new file mode 100755
index 00000000..ff7bf1b0
--- /dev/null
+++ b/server/node_modules/mongodb/node_modules/mongodb-core/lib/topologies/command_result.js
@@ -0,0 +1,37 @@
+"use strict";
+
+var setProperty = require('../connection/utils').setProperty
+ , getProperty = require('../connection/utils').getProperty
+ , getSingleProperty = require('../connection/utils').getSingleProperty;
+
+/**
+ * Creates a new CommandResult instance
+ * @class
+ * @param {object} result CommandResult object
+ * @param {Connection} connection A connection instance associated with this result
+ * @return {CommandResult} A cursor instance
+ */
+var CommandResult = function(result, connection) {
+ this.result = result;
+ this.connection = connection;
+}
+
+/**
+ * Convert CommandResult to JSON
+ * @method
+ * @return {object}
+ */
+CommandResult.prototype.toJSON = function() {
+ return this.result;
+}
+
+/**
+ * Convert CommandResult to String representation
+ * @method
+ * @return {string}
+ */
+CommandResult.prototype.toString = function() {
+ return JSON.stringify(this.toJSON());
+}
+
+module.exports = CommandResult;
\ No newline at end of file
diff --git a/server/node_modules/mongodb/node_modules/mongodb-core/lib/topologies/mongos.js b/server/node_modules/mongodb/node_modules/mongodb-core/lib/topologies/mongos.js
new file mode 100755
index 00000000..59f5a2c6
--- /dev/null
+++ b/server/node_modules/mongodb/node_modules/mongodb-core/lib/topologies/mongos.js
@@ -0,0 +1,931 @@
+"use strict";
+
+var inherits = require('util').inherits
+ , f = require('util').format
+ , b = require('bson')
+ , bindToCurrentDomain = require('../connection/utils').bindToCurrentDomain
+ , EventEmitter = require('events').EventEmitter
+ , BasicCursor = require('../cursor')
+ , BSON = require('bson').native().BSON
+ , BasicCursor = require('../cursor')
+ , Server = require('./server')
+ , Logger = require('../connection/logger')
+ , ReadPreference = require('./read_preference')
+ , Session = require('./session')
+ , MongoError = require('../error');
+
+/**
+ * @fileOverview The **Mongos** class is a class that represents a Mongos Proxy topology and is
+ * used to construct connections.
+ *
+ * @example
+ * var Mongos = require('mongodb-core').Mongos
+ * , ReadPreference = require('mongodb-core').ReadPreference
+ * , assert = require('assert');
+ *
+ * var server = new Mongos([{host: 'localhost', port: 30000}]);
+ * // Wait for the connection event
+ * server.on('connect', function(server) {
+ * server.destroy();
+ * });
+ *
+ * // Start connecting
+ * server.connect();
+ */
+
+var DISCONNECTED = 'disconnected';
+var CONNECTING = 'connecting';
+var CONNECTED = 'connected';
+var DESTROYED = 'destroyed';
+
+// All bson types
+var bsonTypes = [b.Long, b.ObjectID, b.Binary, b.Code, b.DBRef, b.Symbol, b.Double, b.Timestamp, b.MaxKey, b.MinKey];
+// BSON parser
+var bsonInstance = null;
+
+// Instance id
+var mongosId = 0;
+
+//
+// Clone the options
+var cloneOptions = function(options) {
+ var opts = {};
+ for(var name in options) {
+ opts[name] = options[name];
+ }
+ return opts;
+}
+
+var State = function(readPreferenceStrategies) {
+ // Internal state
+ this.s = {
+ connectedServers: []
+ , disconnectedServers: []
+ , readPreferenceStrategies: readPreferenceStrategies
+ }
+}
+
+//
+// A Mongos connected
+State.prototype.connected = function(server) {
+ // Locate in disconnected servers and remove
+ this.s.disconnectedServers = this.s.disconnectedServers.filter(function(s) {
+ return !s.equals(server);
+ });
+
+ var found = false;
+ // Check if the server exists
+ this.s.connectedServers.forEach(function(s) {
+ if(s.equals(server)) found = true;
+ });
+
+ // Add to disconnected list if it does not already exist
+ if(!found) this.s.connectedServers.push(server);
+}
+
+//
+// A Mongos disconnected
+State.prototype.disconnected = function(server) {
+ // Locate in disconnected servers and remove
+ this.s.connectedServers = this.s.connectedServers.filter(function(s) {
+ return !s.equals(server);
+ });
+
+ var found = false;
+ // Check if the server exists
+ this.s.disconnectedServers.forEach(function(s) {
+ if(s.equals(server)) found = true;
+ });
+
+ // Add to disconnected list if it does not already exist
+ if(!found) this.s.disconnectedServers.push(server);
+}
+
+//
+// Return the list of disconnected servers
+State.prototype.disconnectedServers = function() {
+ return this.s.disconnectedServers.slice(0);
+}
+
+//
+// Get connectedServers
+State.prototype.connectedServers = function() {
+ return this.s.connectedServers.slice(0)
+}
+
+//
+// Get all servers
+State.prototype.getAll = function() {
+ return this.s.connectedServers.slice(0).concat(this.s.disconnectedServers);
+}
+
+//
+// Get all connections
+State.prototype.getAllConnections = function() {
+ var connections = [];
+ this.s.connectedServers.forEach(function(e) {
+ connections = connections.concat(e.connections());
+ });
+ return connections;
+}
+
+//
+// Destroy the state
+State.prototype.destroy = function() {
+ // Destroy any connected servers
+ while(this.s.connectedServers.length > 0) {
+ var server = this.s.connectedServers.shift();
+
+ // Remove any non used handlers
+ ['error', 'close', 'timeout', 'connect'].forEach(function(e) {
+ server.removeAllListeners(e);
+ })
+
+ // Server destroy
+ server.destroy();
+ // Add to list of disconnected servers
+ this.s.disconnectedServers.push(server);
+ }
+}
+
+//
+// Are we connected
+State.prototype.isConnected = function() {
+ return this.s.connectedServers.length > 0;
+}
+
+//
+// Pick a server
+State.prototype.pickServer = function(readPreference) {
+ readPreference = readPreference || ReadPreference.primary;
+
+ // Do we have a custom readPreference strategy, use it
+ if(this.s.readPreferenceStrategies != null && this.s.readPreferenceStrategies[readPreference] != null) {
+ return this.s.readPreferenceStrategies[readPreference].pickServer(connectedServers, readPreference);
+ }
+
+ // No valid connections
+ if(this.s.connectedServers.length == 0) throw new MongoError("no mongos proxy available");
+ // Pick first one
+ return this.s.connectedServers[0];
+}
+
+/**
+ * Creates a new Mongos instance
+ * @class
+ * @param {array} seedlist A list of seeds for the replicaset
+ * @param {number} [options.reconnectTries=30] Reconnect retries for HA if no servers available
+ * @param {number} [options.haInterval=5000] The High availability period for replicaset inquiry
+ * @param {boolean} [options.emitError=false] Server will emit errors events
+ * @param {Cursor} [options.cursorFactory=Cursor] The cursor factory class used for all query cursors
+ * @param {number} [options.size=5] Server connection pool size
+ * @param {boolean} [options.keepAlive=true] TCP Connection keep alive enabled
+ * @param {number} [options.keepAliveInitialDelay=0] Initial delay before TCP keep alive enabled
+ * @param {boolean} [options.noDelay=true] TCP Connection no delay
+ * @param {number} [options.connectionTimeout=1000] TCP Connection timeout setting
+ * @param {number} [options.socketTimeout=0] TCP Socket timeout setting
+ * @param {boolean} [options.singleBufferSerializtion=true] Serialize into single buffer, trade of peak memory for serialization speed
+ * @param {boolean} [options.ssl=false] Use SSL for connection
+ * @param {Buffer} [options.ca] SSL Certificate store binary buffer
+ * @param {Buffer} [options.cert] SSL Certificate binary buffer
+ * @param {Buffer} [options.key] SSL Key file binary buffer
+ * @param {string} [options.passphrase] SSL Certificate pass phrase
+ * @param {boolean} [options.rejectUnauthorized=true] Reject unauthorized server certificates
+ * @param {boolean} [options.promoteLongs=true] Convert Long values from the db into Numbers if they fit into 53 bits
+ * @return {Mongos} A cursor instance
+ * @fires Mongos#connect
+ * @fires Mongos#joined
+ * @fires Mongos#left
+ */
+var Mongos = function(seedlist, options) {
+ var self = this;
+ options = options || {};
+
+ // Add event listener
+ EventEmitter.call(this);
+
+ // Validate seedlist
+ if(!Array.isArray(seedlist)) throw new MongoError("seedlist must be an array");
+ // Validate list
+ if(seedlist.length == 0) throw new MongoError("seedlist must contain at least one entry");
+ // Validate entries
+ seedlist.forEach(function(e) {
+ if(typeof e.host != 'string' || typeof e.port != 'number')
+ throw new MongoError("seedlist entry must contain a host and port");
+ });
+
+ // BSON Parser, ensure we have a single instance
+ bsonInstance = bsonInstance == null ? new BSON(bsonTypes) : bsonInstance;
+ // Pick the right bson parser
+ var bson = options.bson ? options.bson : bsonInstance;
+ // Add bson parser to options
+ options.bson = bson;
+
+ // The Mongos state
+ this.s = {
+ // Seed list for sharding passed in
+ seedlist: seedlist
+ // Passed in options
+ , options: options
+ // Logger
+ , logger: Logger('Mongos', options)
+ // Reconnect tries
+ , reconnectTries: options.reconnectTries || 30
+ // Ha interval
+ , haInterval: options.haInterval || 5000
+ // Have omitted fullsetup
+ , fullsetup: false
+ // Cursor factory
+ , Cursor: options.cursorFactory || BasicCursor
+ // Current credentials used for auth
+ , credentials: []
+ // BSON Parser
+ , bsonInstance: bsonInstance
+ , bson: bson
+ // Default state
+ , state: DISCONNECTED
+ // Swallow or emit errors
+ , emitError: typeof options.emitError == 'boolean' ? options.emitError : false
+ // Contains any alternate strategies for picking
+ , readPreferenceStrategies: {}
+ // Auth providers
+ , authProviders: {}
+ // Unique instance id
+ , id: mongosId++
+ // Current retries left
+ , retriesLeft: options.reconnectTries || 30
+ // Do we have a not connected handler
+ , disconnectHandler: options.disconnectHandler
+ }
+
+ // Set up the connection timeout for the options
+ options.connectionTimeout = options.connectionTimeout || 1000;
+
+ // Create a new state for the mongos
+ this.s.mongosState = new State(this.s.readPreferenceStrategies);
+
+ // BSON property (find a server and pass it along)
+ Object.defineProperty(this, 'bson', {
+ enumerable: true, get: function() {
+ var servers = self.s.mongosState.getAll();
+ return servers.length > 0 ? servers[0].bson : null;
+ }
+ });
+
+ Object.defineProperty(this, 'id', {
+ enumerable:true, get: function() { return self.s.id; }
+ });
+
+ Object.defineProperty(this, 'type', {
+ enumerable:true, get: function() { return 'mongos'; }
+ });
+
+ Object.defineProperty(this, 'haInterval', {
+ enumerable:true, get: function() { return self.s.haInterval; }
+ });
+
+ Object.defineProperty(this, 'state', {
+ enumerable:true, get: function() { return self.s.mongosState; }
+ });
+}
+
+inherits(Mongos, EventEmitter);
+
+/**
+ * Execute a command
+ * @method
+ * @param {string} type Type of BSON parser to use (c++ or js)
+ */
+Mongos.prototype.setBSONParserType = function(type) {
+ var nBSON = null;
+
+ if(type == 'c++') {
+ nBSON = require('bson').native().BSON;
+ } else if(type == 'js') {
+ nBSON = require('bson').pure().BSON;
+ } else {
+ throw new MongoError(f("% parser not supported", type));
+ }
+
+ this.s.options.bson = new nBSON(bsonTypes);
+}
+
+/**
+ * Returns the last known ismaster document for this server
+ * @method
+ * @return {object}
+ */
+Mongos.prototype.lastIsMaster = function() {
+ var connectedServers = this.s.mongosState.connectedServers();
+ if(connectedServers.length > 0) return connectedServers[0].lastIsMaster();
+ return null;
+}
+
+/**
+ * Initiate server connect
+ * @method
+ */
+Mongos.prototype.connect = function(_options) {
+ var self = this;
+ // Start replicaset inquiry process
+ setTimeout(mongosInquirer(self, self.s), self.s.haInterval);
+ // Additional options
+ if(_options) for(var name in _options) self.s.options[name] = _options[name];
+ // For all entries in the seedlist build a server instance
+ self.s.seedlist.forEach(function(e) {
+ // Clone options
+ var opts = cloneOptions(self.s.options);
+ // Add host and port
+ opts.host = e.host;
+ opts.port = e.port;
+ opts.reconnect = false;
+ opts.readPreferenceStrategies = self.s.readPreferenceStrategies;
+ // Share the auth store
+ opts.authProviders = self.s.authProviders;
+ // Don't emit errors
+ opts.emitError = true;
+ // Create a new Server
+ self.s.mongosState.disconnected(new Server(opts));
+ });
+
+ // Get the disconnected servers
+ var servers = self.s.mongosState.disconnectedServers();
+
+ // Attempt to connect to all the servers
+ while(servers.length > 0) {
+ // Get the server
+ var server = servers.shift();
+
+ // Remove any non used handlers
+ ['error', 'close', 'timeout', 'connect', 'message', 'parseError'].forEach(function(e) {
+ server.removeAllListeners(e);
+ });
+
+ // Set up the event handlers
+ server.once('error', errorHandlerTemp(self, self.s, server));
+ server.once('close', errorHandlerTemp(self, self.s, server));
+ server.once('timeout', errorHandlerTemp(self, self.s, server));
+ server.once('parseError', errorHandlerTemp(self, self.s, server));
+ server.once('connect', connectHandler(self, self.s, 'connect'));
+
+ if(self.s.logger.isInfo()) self.s.logger.info(f('connecting to server %s', server.name));
+ // Attempt to connect
+ server.connect();
+ }
+}
+
+/**
+ * Destroy the server connection
+ * @method
+ */
+Mongos.prototype.destroy = function(emitClose) {
+ this.s.state = DESTROYED;
+ // Emit close
+ if(emitClose && self.listeners('close').length > 0) self.emit('close', self);
+ // Destroy the state
+ this.s.mongosState.destroy();
+}
+
+/**
+ * Figure out if the server is connected
+ * @method
+ * @return {boolean}
+ */
+Mongos.prototype.isConnected = function() {
+ return this.s.mongosState.isConnected();
+}
+
+//
+// Operations
+//
+
+/**
+ * Insert one or more documents
+ * @method
+ * @param {string} ns The MongoDB fully qualified namespace (ex: db1.collection1)
+ * @param {array} ops An array of documents to insert
+ * @param {boolean} [options.ordered=true] Execute in order or out of order
+ * @param {object} [options.writeConcern={}] Write concern for the operation
+ * @param {opResultCallback} callback A callback function
+ */
+Mongos.prototype.insert = function(ns, ops, options, callback) {
+ // Topology is not connected, save the call in the provided store to be
+ // Executed at some point when the handler deems it's reconnected
+ if(!this.isConnected() && this.s.disconnectHandler != null) {
+ callback = bindToCurrentDomain(callback);
+ return this.s.disconnectHandler.add('insert', ns, ops, options, callback);
+ }
+
+ executeWriteOperation(this.s, 'insert', ns, ops, options, callback);
+}
+
+/**
+ * Perform one or more update operations
+ * @method
+ * @param {string} ns The MongoDB fully qualified namespace (ex: db1.collection1)
+ * @param {array} ops An array of updates
+ * @param {boolean} [options.ordered=true] Execute in order or out of order
+ * @param {object} [options.writeConcern={}] Write concern for the operation
+ * @param {opResultCallback} callback A callback function
+ */
+Mongos.prototype.update = function(ns, ops, options, callback) {
+ // Topology is not connected, save the call in the provided store to be
+ // Executed at some point when the handler deems it's reconnected
+ if(!this.isConnected() && this.s.disconnectHandler != null) {
+ callback = bindToCurrentDomain(callback);
+ return this.s.disconnectHandler.add('update', ns, ops, options, callback);
+ }
+
+ executeWriteOperation(this.s, 'update', ns, ops, options, callback);
+}
+
+/**
+ * Perform one or more remove operations
+ * @method
+ * @param {string} ns The MongoDB fully qualified namespace (ex: db1.collection1)
+ * @param {array} ops An array of removes
+ * @param {boolean} [options.ordered=true] Execute in order or out of order
+ * @param {object} [options.writeConcern={}] Write concern for the operation
+ * @param {opResultCallback} callback A callback function
+ */
+Mongos.prototype.remove = function(ns, ops, options, callback) {
+ // Topology is not connected, save the call in the provided store to be
+ // Executed at some point when the handler deems it's reconnected
+ if(!this.isConnected() && this.s.disconnectHandler != null) {
+ callback = bindToCurrentDomain(callback);
+ return this.s.disconnectHandler.add('remove', ns, ops, options, callback);
+ }
+
+ executeWriteOperation(this.s, 'remove', ns, ops, options, callback);
+}
+
+/**
+ * Execute a command
+ * @method
+ * @param {string} ns The MongoDB fully qualified namespace (ex: db1.collection1)
+ * @param {object} cmd The command hash
+ * @param {ReadPreference} [options.readPreference] Specify read preference if command supports it
+ * @param {Connection} [options.connection] Specify connection object to execute command against
+ * @param {opResultCallback} callback A callback function
+ */
+Mongos.prototype.command = function(ns, cmd, options, callback) {
+ var self = this;
+ if(typeof options == 'function') {
+ callback = options;
+ options = {};
+ }
+
+ // Topology is not connected, save the call in the provided store to be
+ // Executed at some point when the handler deems it's reconnected
+ if(!self.isConnected() && self.s.disconnectHandler != null) {
+ callback = bindToCurrentDomain(callback);
+ return self.s.disconnectHandler.add('command', ns, cmd, options, callback);
+ }
+
+ var server = null;
+ // Ensure we have no options
+ options = options || {};
+
+ // We need to execute the command on all servers
+ if(options.onAll) {
+ var servers = self.s.mongosState.getAll();
+ var count = servers.length;
+ var cmdErr = null;
+
+ for(var i = 0; i < servers.length; i++) {
+ servers[i].command(ns, cmd, options, function(err, r) {
+ count = count - 1;
+ // Finished executing command
+ if(count == 0) {
+ // Was it a logout command clear any credentials
+ if(cmd.logout) clearCredentials(state, ns);
+ // Return the error
+ callback(err, r);
+ }
+ });
+ }
+
+ return;
+ }
+
+
+ try {
+ // Get a primary
+ server = self.s.mongosState.pickServer(options.writeConcern ? ReadPreference.primary : options.readPreference);
+ } catch(err) {
+ return callback(err);
+ }
+
+ // No server returned we had an error
+ if(server == null) return callback(new MongoError("no mongos found"));
+ server.command(ns, cmd, options, function(err, r) {
+ // Was it a logout command clear any credentials
+ if(cmd.logout) clearCredentials(self.s, ns);
+ callback(err, r);
+ });
+}
+
+/**
+ * Perform one or more remove operations
+ * @method
+ * @param {string} ns The MongoDB fully qualified namespace (ex: db1.collection1)
+ * @param {{object}|{Long}} cmd Can be either a command returning a cursor or a cursorId
+ * @param {object} [options.batchSize=0] Batchsize for the operation
+ * @param {array} [options.documents=[]] Initial documents list for cursor
+ * @param {ReadPreference} [options.readPreference] Specify read preference if command supports it
+ * @param {opResultCallback} callback A callback function
+ */
+Mongos.prototype.cursor = function(ns, cmd, cursorOptions) {
+ cursorOptions = cursorOptions || {};
+ var FinalCursor = cursorOptions.cursorFactory || this.s.Cursor;
+ return new FinalCursor(this.s.bson, ns, cmd, cursorOptions, this, this.s.options);
+}
+
+/**
+ * Authenticate using a specified mechanism
+ * @method
+ * @param {string} mechanism The Auth mechanism we are invoking
+ * @param {string} db The db we are invoking the mechanism against
+ * @param {...object} param Parameters for the specific mechanism
+ * @param {authResultCallback} callback A callback function
+ */
+Mongos.prototype.auth = function(mechanism, db) {
+ var self = this;
+ var args = Array.prototype.slice.call(arguments, 2);
+ var callback = args.pop();
+ // If we don't have the mechanism fail
+ if(self.s.authProviders[mechanism] == null && mechanism != 'default')
+ throw new MongoError(f("auth provider %s does not exist", mechanism));
+
+ // Authenticate against all the servers
+ var servers = self.s.mongosState.connectedServers();
+ var count = servers.length;
+ // Correct authentication
+ var authenticated = true;
+ var authErr = null;
+
+ // Authenticate against all servers
+ while(servers.length > 0) {
+ var server = servers.shift();
+
+ // Create arguments
+ var finalArguments = [mechanism, db].concat(args.slice(0)).concat([function(err, r) {
+ count = count - 1;
+ if(err) authErr = err;
+ if(!r) authenticated = false;
+
+ // We are done
+ if(count == 0) {
+ if(authErr) return callback(authErr, false);
+ callback(null, new Session({}, self));
+ }
+ }]);
+
+ // Execute the auth
+ server.auth.apply(server, finalArguments);
+ }
+}
+
+//
+// Plugin methods
+//
+
+/**
+ * Add custom read preference strategy
+ * @method
+ * @param {string} name Name of the read preference strategy
+ * @param {object} strategy Strategy object instance
+ */
+Mongos.prototype.addReadPreferenceStrategy = function(name, strategy) {
+ if(this.s.readPreferenceStrategies == null) this.s.readPreferenceStrategies = {};
+ this.s.readPreferenceStrategies[name] = strategy;
+}
+
+/**
+ * Add custom authentication mechanism
+ * @method
+ * @param {string} name Name of the authentication mechanism
+ * @param {object} provider Authentication object instance
+ */
+Mongos.prototype.addAuthProvider = function(name, provider) {
+ this.s.authProviders[name] = provider;
+}
+
+/**
+ * Get connection
+ * @method
+ * @param {ReadPreference} [options.readPreference] Specify read preference if command supports it
+ * @return {Connection}
+ */
+Mongos.prototype.getConnection = function(options) {
+ // Ensure we have no options
+ options = options || {};
+ // Pick the right server based on readPreference
+ var server = this.s.mongosState.pickServer(options.readPreference);
+ if(server == null) return null;
+ // Return connection
+ return server.getConnection();
+}
+
+/**
+ * Get server
+ * @method
+ * @param {ReadPreference} [options.readPreference] Specify read preference if command supports it
+ * @return {Server}
+ */
+Mongos.prototype.getServer = function(options) {
+ // Ensure we have no options
+ options = options || {};
+ // Pick the right server based on readPreference
+ return this.s.mongosState.pickServer(options.readPreference);
+}
+
+/**
+ * All raw connections
+ * @method
+ * @return {Connection[]}
+ */
+Mongos.prototype.connections = function() {
+ return this.s.mongosState.getAllConnections();
+}
+
+//
+// Inquires about state changes
+//
+var mongosInquirer = function(self, state) {
+ return function() {
+ if(state.state == DESTROYED) return
+ if(state.state == CONNECTED) state.retriesLeft = state.reconnectTries;
+
+ // If we have a disconnected site
+ if(state.state == DISCONNECTED && state.retriesLeft == 0) {
+ self.destroy();
+ return self.emit('error', new MongoError(f('failed to reconnect after %s', state.reconnectTries)));
+ } else if(state == DISCONNECTED) {
+ state.retriesLeft = state.retriesLeft - 1;
+ }
+
+ // If we have a primary and a disconnect handler, execute
+ // buffered operations
+ if(state.mongosState.isConnected() && state.disconnectHandler) {
+ state.disconnectHandler.execute();
+ }
+
+ // Log the information
+ if(state.logger.isDebug()) state.logger.debug(f('mongos ha proceess running'));
+
+ // Let's query any disconnected proxies
+ var disconnectedServers = state.mongosState.disconnectedServers();
+ if(disconnectedServers.length == 0) return setTimeout(mongosInquirer(self, state), state.haInterval);
+
+ // Count of connections waiting to be connected
+ var connectionCount = disconnectedServers.length;
+ if(state.logger.isDebug()) state.logger.debug(f('mongos ha proceess found %d disconnected proxies', connectionCount));
+
+ // Let's attempt to reconnect
+ while(disconnectedServers.length > 0) {
+ var server = disconnectedServers.shift();
+ if(state.logger.isDebug()) state.logger.debug(f('attempting to connect to server %s', server.name));
+
+ // Remove any listeners
+ ['error', 'close', 'timeout', 'connect', 'message', 'parseError'].forEach(function(e) {
+ server.removeAllListeners(e);
+ });
+
+ // Set up the event handlers
+ server.once('error', errorHandlerTemp(self, state, server));
+ server.once('close', errorHandlerTemp(self, state, server));
+ server.once('timeout', errorHandlerTemp(self, state, server));
+ server.once('connect', connectHandler(self, state, 'ha'));
+ // Start connect
+ server.connect();
+ }
+
+ // Let's keep monitoring but wait for possible timeout to happen
+ return setTimeout(mongosInquirer(self, state), state.options.connectionTimeout + state.haInterval);
+ }
+}
+
+//
+// Error handler for initial connect
+var errorHandlerTemp = function(self, state, server) {
+ return function(err, server) {
+ // Log the information
+ if(state.logger.isInfo()) state.logger.info(f('server %s disconnected with error %s', server.name, JSON.stringify(err)));
+
+ // Remove any non used handlers
+ ['error', 'close', 'timeout', 'connect'].forEach(function(e) {
+ server.removeAllListeners(e);
+ })
+
+ // Signal disconnect of server
+ state.mongosState.disconnected(server);
+ }
+}
+
+//
+// Handlers
+var errorHandler = function(self, state) {
+ return function(err, server) {
+ if(state.logger.isInfo()) state.logger.info(f('server %s errored out with %s', server.name, JSON.stringify(err)));
+ state.mongosState.disconnected(server);
+ // No more servers left emit close
+ if(state.mongosState.connectedServers().length == 0) {
+ state.state = DISCONNECTED;
+ }
+
+ // Signal server left
+ self.emit('left', 'mongos', server);
+ if(state.emitError) self.emit('error', err, server);
+ }
+}
+
+var timeoutHandler = function(self, state) {
+ return function(err, server) {
+ if(state.logger.isInfo()) state.logger.info(f('server %s timed out', server.name));
+ state.mongosState.disconnected(server);
+
+ // No more servers emit close event if no entries left
+ if(state.mongosState.connectedServers().length == 0) {
+ state.state = DISCONNECTED;
+ }
+
+ // Signal server left
+ self.emit('left', 'mongos', server);
+ }
+}
+
+var closeHandler = function(self, state) {
+ return function(err, server) {
+ if(state.logger.isInfo()) state.logger.info(f('server %s closed', server.name));
+ state.mongosState.disconnected(server);
+
+ // No more servers left emit close
+ if(state.mongosState.connectedServers().length == 0) {
+ state.state = DISCONNECTED;
+ }
+
+ // Signal server left
+ self.emit('left', 'mongos', server);
+ }
+}
+
+// Connect handler
+var connectHandler = function(self, state, e) {
+ return function(server) {
+ if(state.logger.isInfo()) state.logger.info(f('connected to %s', server.name));
+
+ // Remove any non used handlers
+ ['error', 'close', 'timeout', 'connect', 'message', 'parseError'].forEach(function(e) {
+ server.removeAllListeners(e);
+ });
+
+ // finish processing the server
+ var processNewServer = function(_server) {
+ // Add the server handling code
+ if(_server.isConnected()) {
+ _server.once('error', errorHandler(self, state));
+ _server.once('close', closeHandler(self, state));
+ _server.once('timeout', timeoutHandler(self, state));
+ _server.once('parseError', timeoutHandler(self, state));
+ }
+
+ // Emit joined event
+ self.emit('joined', 'mongos', _server);
+
+ // Add to list connected servers
+ state.mongosState.connected(_server);
+
+ // Do we have a reconnect event
+ if('ha' == e && state.mongosState.connectedServers().length == 1) {
+ self.emit('reconnect', _server);
+ }
+
+ if(state.mongosState.disconnectedServers().length == 0 &&
+ state.mongosState.connectedServers().length > 0 &&
+ !state.fullsetup) {
+ state.fullsetup = true;
+ self.emit('fullsetup');
+ }
+
+ // Set connected
+ if(state.state == DISCONNECTED) {
+ state.state = CONNECTED;
+ self.emit('connect', self);
+ }
+ }
+
+ // No credentials just process server
+ if(state.credentials.length == 0) return processNewServer(server);
+
+ // Do we have credentials, let's apply them all
+ var count = state.credentials.length;
+ // Apply the credentials
+ for(var i = 0; i < state.credentials.length; i++) {
+ server.auth.apply(server, state.credentials[i].concat([function(err, r) {
+ count = count - 1;
+ if(count == 0) processNewServer(server);
+ }]));
+ }
+ }
+}
+
+//
+// Add server to the list if it does not exist
+var addToListIfNotExist = function(list, server) {
+ var found = false;
+
+ // Remove any non used handlers
+ ['error', 'close', 'timeout', 'connect'].forEach(function(e) {
+ server.removeAllListeners(e);
+ })
+
+ // Check if the server already exists
+ for(var i = 0; i < list.length; i++) {
+ if(list[i].equals(server)) found = true;
+ }
+
+ if(!found) {
+ list.push(server);
+ }
+}
+
+// Add the new credential for a db, removing the old
+// credential from the cache
+var addCredentials = function(state, db, argsWithoutCallback) {
+ // Remove any credentials for the db
+ clearCredentials(state, db + ".dummy");
+ // Add new credentials to list
+ state.credentials.push(argsWithoutCallback);
+}
+
+// Clear out credentials for a namespace
+var clearCredentials = function(state, ns) {
+ var db = ns.split('.')[0];
+ var filteredCredentials = [];
+
+ // Filter out all credentials for the db the user is logging out off
+ for(var i = 0; i < state.credentials.length; i++) {
+ if(state.credentials[i][1] != db) filteredCredentials.push(state.credentials[i]);
+ }
+
+ // Set new list of credentials
+ state.credentials = filteredCredentials;
+}
+
+var processReadPreference = function(cmd, options) {
+ options = options || {}
+ // No read preference specified
+ if(options.readPreference == null) return cmd;
+}
+
+//
+// Execute write operation
+var executeWriteOperation = function(state, op, ns, ops, options, callback) {
+ if(typeof options == 'function') {
+ callback = options;
+ options = {};
+ }
+
+ var server = null;
+ // Ensure we have no options
+ options = options || {};
+ try {
+ // Get a primary
+ server = state.mongosState.pickServer();
+ } catch(err) {
+ return callback(err);
+ }
+
+ // No server returned we had an error
+ if(server == null) return callback(new MongoError("no mongos found"));
+ // Execute the command
+ server[op](ns, ops, options, callback);
+}
+
+/**
+ * A mongos connect event, used to verify that the connection is up and running
+ *
+ * @event Mongos#connect
+ * @type {Mongos}
+ */
+
+/**
+ * A server member left the mongos list
+ *
+ * @event Mongos#left
+ * @type {Mongos}
+ * @param {string} type The type of member that left (mongos)
+ * @param {Server} server The server object that left
+ */
+
+/**
+ * A server member joined the mongos list
+ *
+ * @event Mongos#joined
+ * @type {Mongos}
+ * @param {string} type The type of member that left (mongos)
+ * @param {Server} server The server object that joined
+ */
+
+module.exports = Mongos;
\ No newline at end of file
diff --git a/server/node_modules/mongodb/node_modules/mongodb-core/lib/topologies/read_preference.js b/server/node_modules/mongodb/node_modules/mongodb-core/lib/topologies/read_preference.js
new file mode 100755
index 00000000..913ca1b8
--- /dev/null
+++ b/server/node_modules/mongodb/node_modules/mongodb-core/lib/topologies/read_preference.js
@@ -0,0 +1,106 @@
+"use strict";
+
+var needSlaveOk = ['primaryPreferred', 'secondary', 'secondaryPreferred', 'nearest'];
+
+/**
+ * @fileOverview The **ReadPreference** class is a class that represents a MongoDB ReadPreference and is
+ * used to construct connections.
+ *
+ * @example
+ * var ReplSet = require('mongodb-core').ReplSet
+ * , ReadPreference = require('mongodb-core').ReadPreference
+ * , assert = require('assert');
+ *
+ * var server = new ReplSet([{host: 'localhost', port: 30000}], {setName: 'rs'});
+ * // Wait for the connection event
+ * server.on('connect', function(server) {
+ * var cursor = server.cursor('db.test'
+ * , {find: 'db.test', query: {}}
+ * , {readPreference: new ReadPreference('secondary')});
+ * cursor.next(function(err, doc) {
+ * server.destroy();
+ * });
+ * });
+ *
+ * // Start connecting
+ * server.connect();
+ */
+
+/**
+ * Creates a new Pool instance
+ * @class
+ * @param {string} preference A string describing the preference (primary|primaryPreferred|secondary|secondaryPreferred|nearest)
+ * @param {object} tags The tags object
+ * @param {object} [options] Additional read preference options
+ * @property {string} preference The preference string (primary|primaryPreferred|secondary|secondaryPreferred|nearest)
+ * @property {object} tags The tags object
+ * @property {object} options Additional read preference options
+ * @return {ReadPreference}
+ */
+var ReadPreference = function(preference, tags, options) {
+ this.preference = preference;
+ this.tags = tags;
+ this.options = options;
+}
+
+/**
+ * This needs slaveOk bit set
+ * @method
+ * @return {boolean}
+ */
+ReadPreference.prototype.slaveOk = function() {
+ return needSlaveOk.indexOf(this.preference) != -1;
+}
+
+/**
+ * Are the two read preference equal
+ * @method
+ * @return {boolean}
+ */
+ReadPreference.prototype.equals = function(readPreference) {
+ return readPreference.preference == this.preference;
+}
+
+/**
+ * Return JSON representation
+ * @method
+ * @return {Object}
+ */
+ReadPreference.prototype.toJSON = function() {
+ var readPreference = {mode: this.preference};
+ if(Array.isArray(this.tags)) readPreference.tags = this.tags;
+ return readPreference;
+}
+
+/**
+ * Primary read preference
+ * @method
+ * @return {ReadPreference}
+ */
+ReadPreference.primary = new ReadPreference('primary');
+/**
+ * Primary Preferred read preference
+ * @method
+ * @return {ReadPreference}
+ */
+ReadPreference.primaryPreferred = new ReadPreference('primaryPreferred');
+/**
+ * Secondary read preference
+ * @method
+ * @return {ReadPreference}
+ */
+ReadPreference.secondary = new ReadPreference('secondary');
+/**
+ * Secondary Preferred read preference
+ * @method
+ * @return {ReadPreference}
+ */
+ReadPreference.secondaryPreferred = new ReadPreference('secondaryPreferred');
+/**
+ * Nearest read preference
+ * @method
+ * @return {ReadPreference}
+ */
+ReadPreference.nearest = new ReadPreference('nearest');
+
+module.exports = ReadPreference;
\ No newline at end of file
diff --git a/server/node_modules/mongodb/node_modules/mongodb-core/lib/topologies/replset.js b/server/node_modules/mongodb/node_modules/mongodb-core/lib/topologies/replset.js
new file mode 100755
index 00000000..977c0cd7
--- /dev/null
+++ b/server/node_modules/mongodb/node_modules/mongodb-core/lib/topologies/replset.js
@@ -0,0 +1,1265 @@
+"use strict";
+
+var inherits = require('util').inherits
+ , f = require('util').format
+ , b = require('bson')
+ , bindToCurrentDomain = require('../connection/utils').bindToCurrentDomain
+ , debugOptions = require('../connection/utils').debugOptions
+ , EventEmitter = require('events').EventEmitter
+ , Server = require('./server')
+ , ReadPreference = require('./read_preference')
+ , MongoError = require('../error')
+ , Ping = require('./strategies/ping')
+ , Session = require('./session')
+ , BasicCursor = require('../cursor')
+ , BSON = require('bson').native().BSON
+ , State = require('./replset_state')
+ , Logger = require('../connection/logger');
+
+/**
+ * @fileOverview The **ReplSet** class is a class that represents a Replicaset topology and is
+ * used to construct connecctions.
+ *
+ * @example
+ * var ReplSet = require('mongodb-core').ReplSet
+ * , ReadPreference = require('mongodb-core').ReadPreference
+ * , assert = require('assert');
+ *
+ * var server = new ReplSet([{host: 'localhost', port: 30000}], {setName: 'rs'});
+ * // Wait for the connection event
+ * server.on('connect', function(server) {
+ * server.destroy();
+ * });
+ *
+ * // Start connecting
+ * server.connect();
+ */
+
+var DISCONNECTED = 'disconnected';
+var CONNECTING = 'connecting';
+var CONNECTED = 'connected';
+var DESTROYED = 'destroyed';
+
+//
+// ReplSet instance id
+var replSetId = 1;
+
+//
+// Clone the options
+var cloneOptions = function(options) {
+ var opts = {};
+ for(var name in options) {
+ opts[name] = options[name];
+ }
+ return opts;
+}
+
+// All bson types
+var bsonTypes = [b.Long, b.ObjectID, b.Binary, b.Code, b.DBRef, b.Symbol, b.Double, b.Timestamp, b.MaxKey, b.MinKey];
+// BSON parser
+var bsonInstance = null;
+
+/**
+ * Creates a new Replset instance
+ * @class
+ * @param {array} seedlist A list of seeds for the replicaset
+ * @param {boolean} options.setName The Replicaset set name
+ * @param {boolean} [options.secondaryOnlyConnectionAllowed=false] Allow connection to a secondary only replicaset
+ * @param {number} [options.haInterval=5000] The High availability period for replicaset inquiry
+ * @param {boolean} [options.emitError=false] Server will emit errors events
+ * @param {Cursor} [options.cursorFactory=Cursor] The cursor factory class used for all query cursors
+ * @param {number} [options.size=5] Server connection pool size
+ * @param {boolean} [options.keepAlive=true] TCP Connection keep alive enabled
+ * @param {number} [options.keepAliveInitialDelay=0] Initial delay before TCP keep alive enabled
+ * @param {boolean} [options.noDelay=true] TCP Connection no delay
+ * @param {number} [options.connectionTimeout=0] TCP Connection timeout setting
+ * @param {number} [options.socketTimeout=0] TCP Socket timeout setting
+ * @param {boolean} [options.singleBufferSerializtion=true] Serialize into single buffer, trade of peak memory for serialization speed
+ * @param {boolean} [options.ssl=false] Use SSL for connection
+ * @param {Buffer} [options.ca] SSL Certificate store binary buffer
+ * @param {Buffer} [options.cert] SSL Certificate binary buffer
+ * @param {Buffer} [options.key] SSL Key file binary buffer
+ * @param {string} [options.passphrase] SSL Certificate pass phrase
+ * @param {boolean} [options.rejectUnauthorized=true] Reject unauthorized server certificates
+ * @param {boolean} [options.promoteLongs=true] Convert Long values from the db into Numbers if they fit into 53 bits
+ * @param {number} [options.pingInterval=5000] Ping interval to check the response time to the different servers
+ * @param {number} [options.acceptableLatency=250] Acceptable latency for selecting a server for reading (in milliseconds)
+ * @return {ReplSet} A cursor instance
+ * @fires ReplSet#connect
+ * @fires ReplSet#ha
+ * @fires ReplSet#joined
+ * @fires ReplSet#left
+ */
+var ReplSet = function(seedlist, options) {
+ var self = this;
+ options = options || {};
+
+ // Validate seedlist
+ if(!Array.isArray(seedlist)) throw new MongoError("seedlist must be an array");
+ // Validate list
+ if(seedlist.length == 0) throw new MongoError("seedlist must contain at least one entry");
+ // Validate entries
+ seedlist.forEach(function(e) {
+ if(typeof e.host != 'string' || typeof e.port != 'number')
+ throw new MongoError("seedlist entry must contain a host and port");
+ });
+
+ // Add event listener
+ EventEmitter.call(this);
+
+ // Set the bson instance
+ bsonInstance = bsonInstance == null ? new BSON(bsonTypes) : bsonInstance;
+
+ // Internal state hash for the object
+ this.s = {
+ options: options
+ // Logger instance
+ , logger: Logger('ReplSet', options)
+ // Uniquely identify the replicaset instance
+ , id: replSetId++
+ // Index
+ , index: 0
+ // Ha Index
+ , haId: 0
+ // Current credentials used for auth
+ , credentials: []
+ // Factory overrides
+ , Cursor: options.cursorFactory || BasicCursor
+ // BSON Parser, ensure we have a single instance
+ , bsonInstance: bsonInstance
+ // Pick the right bson parser
+ , bson: options.bson ? options.bson : bsonInstance
+ // Special replicaset options
+ , secondaryOnlyConnectionAllowed: typeof options.secondaryOnlyConnectionAllowed == 'boolean'
+ ? options.secondaryOnlyConnectionAllowed : false
+ , haInterval: options.haInterval || 10000
+ // Are we running in debug mode
+ , debug: typeof options.debug == 'boolean' ? options.debug : false
+ // The replicaset name
+ , setName: options.setName
+ // Swallow or emit errors
+ , emitError: typeof options.emitError == 'boolean' ? options.emitError : false
+ // Grouping tag used for debugging purposes
+ , tag: options.tag
+ // Do we have a not connected handler
+ , disconnectHandler: options.disconnectHandler
+ // Currently connecting servers
+ , connectingServers: {}
+ // Contains any alternate strategies for picking
+ , readPreferenceStrategies: {}
+ // Auth providers
+ , authProviders: {}
+ // All the servers
+ , disconnectedServers: []
+ // Initial connection servers
+ , initialConnectionServers: []
+ // High availability process running
+ , highAvailabilityProcessRunning: false
+ // Full setup
+ , fullsetup: false
+ // All servers accounted for (used for testing)
+ , all: false
+ // Seedlist
+ , seedlist: seedlist
+ // Authentication in progress
+ , authInProgress: false
+ // Servers added while auth in progress
+ , authInProgressServers: []
+ // Minimum heartbeat frequency used if we detect a server close
+ , minHeartbeatFrequencyMS: 500
+ }
+
+ // Add bson parser to options
+ options.bson = this.s.bson;
+ // Set up the connection timeout for the options
+ options.connectionTimeout = options.connectionTimeout || 10000;
+
+ // Replicaset state
+ var replState = new State(this, {
+ id: this.s.id, setName: this.s.setName
+ , connectingServers: this.s.connectingServers
+ , secondaryOnlyConnectionAllowed: this.s.secondaryOnlyConnectionAllowed
+ });
+
+ // Add Replicaset state to our internal state
+ this.s.replState = replState;
+
+ // BSON property (find a server and pass it along)
+ Object.defineProperty(this, 'bson', {
+ enumerable: true, get: function() {
+ var servers = self.s.replState.getAll();
+ return servers.length > 0 ? servers[0].bson : null;
+ }
+ });
+
+ Object.defineProperty(this, 'id', {
+ enumerable:true, get: function() { return self.s.id; }
+ });
+
+ Object.defineProperty(this, 'haInterval', {
+ enumerable:true, get: function() { return self.s.haInterval; }
+ });
+
+ Object.defineProperty(this, 'state', {
+ enumerable:true, get: function() { return self.s.replState; }
+ });
+
+ //
+ // Debug options
+ if(self.s.debug) {
+ // Add access to the read Preference Strategies
+ Object.defineProperty(this, 'readPreferenceStrategies', {
+ enumerable: true, get: function() { return self.s.readPreferenceStrategies; }
+ });
+ }
+
+ Object.defineProperty(this, 'type', {
+ enumerable:true, get: function() { return 'replset'; }
+ });
+
+ // Add the ping strategy for nearest
+ this.addReadPreferenceStrategy('nearest', new Ping(options));
+}
+
+inherits(ReplSet, EventEmitter);
+
+//
+// Plugin methods
+//
+
+/**
+ * Add custom read preference strategy
+ * @method
+ * @param {string} name Name of the read preference strategy
+ * @param {object} strategy Strategy object instance
+ */
+ReplSet.prototype.addReadPreferenceStrategy = function(name, func) {
+ this.s.readPreferenceStrategies[name] = func;
+}
+
+/**
+ * Add custom authentication mechanism
+ * @method
+ * @param {string} name Name of the authentication mechanism
+ * @param {object} provider Authentication object instance
+ */
+ReplSet.prototype.addAuthProvider = function(name, provider) {
+ if(this.s.authProviders == null) this.s.authProviders = {};
+ this.s.authProviders[name] = provider;
+}
+
+/**
+ * Name of BSON parser currently used
+ * @method
+ * @return {string}
+ */
+ReplSet.prototype.parserType = function() {
+ if(this.s.bson.serialize.toString().indexOf('[native code]') != -1)
+ return 'c++';
+ return 'js';
+}
+
+/**
+ * Execute a command
+ * @method
+ * @param {string} type Type of BSON parser to use (c++ or js)
+ */
+ReplSet.prototype.setBSONParserType = function(type) {
+ var nBSON = null;
+
+ if(type == 'c++') {
+ nBSON = require('bson').native().BSON;
+ } else if(type == 'js') {
+ nBSON = require('bson').pure().BSON;
+ } else {
+ throw new MongoError(f("% parser not supported", type));
+ }
+
+ this.s.options.bson = new nBSON(bsonTypes);
+}
+
+/**
+ * Returns the last known ismaster document for this server
+ * @method
+ * @return {object}
+ */
+ReplSet.prototype.lastIsMaster = function() {
+ return this.s.replState.lastIsMaster();
+}
+
+/**
+ * Get connection
+ * @method
+ * @param {ReadPreference} [options.readPreference] Specify read preference if command supports it
+ * @return {Connection}
+ */
+ReplSet.prototype.getConnection = function(options) {
+ // Ensure we have no options
+ options = options || {};
+ // Pick the right server based on readPreference
+ var server = pickServer(this, this.s, options.readPreference);
+ if(server == null) return null;
+ // Return connection
+ return server.getConnection();
+}
+
+/**
+ * All raw connections
+ * @method
+ * @return {Connection[]}
+ */
+ReplSet.prototype.connections = function() {
+ return this.s.replState.getAllConnections();
+}
+
+/**
+ * Get server
+ * @method
+ * @param {ReadPreference} [options.readPreference] Specify read preference if command supports it
+ * @return {Server}
+ */
+ReplSet.prototype.getServer = function(options) {
+ // Ensure we have no options
+ options = options || {};
+ // Pick the right server based on readPreference
+ return pickServer(this, this.s, options.readPreference);
+}
+
+/**
+ * Perform one or more remove operations
+ * @method
+ * @param {string} ns The MongoDB fully qualified namespace (ex: db1.collection1)
+ * @param {{object}|{Long}} cmd Can be either a command returning a cursor or a cursorId
+ * @param {object} [options.batchSize=0] Batchsize for the operation
+ * @param {array} [options.documents=[]] Initial documents list for cursor
+ * @param {ReadPreference} [options.readPreference] Specify read preference if command supports it
+ * @param {opResultCallback} callback A callback function
+ */
+ReplSet.prototype.cursor = function(ns, cmd, cursorOptions) {
+ cursorOptions = cursorOptions || {};
+ var FinalCursor = cursorOptions.cursorFactory || this.s.Cursor;
+ return new FinalCursor(this.s.bson, ns, cmd, cursorOptions, this, this.s.options);
+}
+
+//
+// Execute write operation
+var executeWriteOperation = function(self, op, ns, ops, options, callback) {
+ if(typeof options == 'function') {
+ callback = options;
+ options = {};
+ }
+
+ var server = null;
+ // Ensure we have no options
+ options = options || {};
+ // Get a primary
+ try {
+ server = pickServer(self, self.s, ReadPreference.primary);
+ if(self.s.debug) self.emit('pickedServer', ReadPreference.primary, server);
+ } catch(err) {
+ return callback(err);
+ }
+
+ // No server returned we had an error
+ if(server == null) return callback(new MongoError("no server found"));
+
+ // Execute the command
+ server[op](ns, ops, options, function(err, r) {
+ // We have a no master error, immediately refresh the view of the replicaset
+ if(notMasterError(r) || notMasterError(err)) replicasetInquirer(self, self.s, true)();
+ // Return the result
+ callback(err, r);
+ });
+}
+
+/**
+ * Execute a command
+ * @method
+ * @param {string} ns The MongoDB fully qualified namespace (ex: db1.collection1)
+ * @param {object} cmd The command hash
+ * @param {ReadPreference} [options.readPreference] Specify read preference if command supports it
+ * @param {Connection} [options.connection] Specify connection object to execute command against
+ * @param {opResultCallback} callback A callback function
+ */
+ReplSet.prototype.command = function(ns, cmd, options, callback) {
+ if(typeof options == 'function') {
+ callback = options;
+ options = {};
+ }
+
+ var server = null;
+ var self = this;
+ // Ensure we have no options
+ options = options || {};
+
+ // Topology is not connected, save the call in the provided store to be
+ // Executed at some point when the handler deems it's reconnected
+ if(!this.isConnected(options) && this.s.disconnectHandler != null) {
+ callback = bindToCurrentDomain(callback);
+ return this.s.disconnectHandler.add('command', ns, cmd, options, callback);
+ }
+
+ // We need to execute the command on all servers
+ if(options.onAll) {
+ var servers = this.s.replState.getAll();
+ var count = servers.length;
+ var cmdErr = null;
+
+ for(var i = 0; i < servers.length; i++) {
+ servers[i].command(ns, cmd, options, function(err, r) {
+ count = count - 1;
+ // Finished executing command
+ if(count == 0) {
+ // Was it a logout command clear any credentials
+ if(cmd.logout) clearCredentials(self.s, ns);
+ // We have a no master error, immediately refresh the view of the replicaset
+ if(notMasterError(r) || notMasterError(err)) replicasetInquirer(self, self.s, true)();
+ // Return the error
+ callback(err, r);
+ }
+ });
+ }
+
+ return;
+ }
+
+ // Pick the right server based on readPreference
+ try {
+ server = pickServer(self, self.s, options.writeConcern ? ReadPreference.primary : options.readPreference);
+ if(self.s.debug) self.emit('pickedServer', options.writeConcern ? ReadPreference.primary : options.readPreference, server);
+ } catch(err) {
+ return callback(err);
+ }
+
+ // No server returned we had an error
+ if(server == null) return callback(new MongoError("no server found"));
+ // Execute the command
+ server.command(ns, cmd, options, function(err, r) {
+ // Was it a logout command clear any credentials
+ if(cmd.logout) clearCredentials(self.s, ns);
+ // We have a no master error, immediately refresh the view of the replicaset
+ if(notMasterError(r) || notMasterError(err)) {
+ replicasetInquirer(self, self.s, true)();
+ }
+ // Return the error
+ callback(err, r);
+ });
+}
+
+/**
+ * Perform one or more remove operations
+ * @method
+ * @param {string} ns The MongoDB fully qualified namespace (ex: db1.collection1)
+ * @param {array} ops An array of removes
+ * @param {boolean} [options.ordered=true] Execute in order or out of order
+ * @param {object} [options.writeConcern={}] Write concern for the operation
+ * @param {opResultCallback} callback A callback function
+ */
+ReplSet.prototype.remove = function(ns, ops, options, callback) {
+ // Topology is not connected, save the call in the provided store to be
+ // Executed at some point when the handler deems it's reconnected
+ if(!this.isConnected() && this.s.disconnectHandler != null) {
+ callback = bindToCurrentDomain(callback);
+ return this.s.disconnectHandler.add('remove', ns, ops, options, callback);
+ }
+
+ executeWriteOperation(this, 'remove', ns, ops, options, callback);
+}
+
+/**
+ * Insert one or more documents
+ * @method
+ * @param {string} ns The MongoDB fully qualified namespace (ex: db1.collection1)
+ * @param {array} ops An array of documents to insert
+ * @param {boolean} [options.ordered=true] Execute in order or out of order
+ * @param {object} [options.writeConcern={}] Write concern for the operation
+ * @param {opResultCallback} callback A callback function
+ */
+ReplSet.prototype.insert = function(ns, ops, options, callback) {
+ // Topology is not connected, save the call in the provided store to be
+ // Executed at some point when the handler deems it's reconnected
+ if(!this.isConnected() && this.s.disconnectHandler != null) {
+ callback = bindToCurrentDomain(callback);
+ return this.s.disconnectHandler.add('insert', ns, ops, options, callback);
+ }
+
+ executeWriteOperation(this, 'insert', ns, ops, options, callback);
+}
+
+/**
+ * Perform one or more update operations
+ * @method
+ * @param {string} ns The MongoDB fully qualified namespace (ex: db1.collection1)
+ * @param {array} ops An array of updates
+ * @param {boolean} [options.ordered=true] Execute in order or out of order
+ * @param {object} [options.writeConcern={}] Write concern for the operation
+ * @param {opResultCallback} callback A callback function
+ */
+ReplSet.prototype.update = function(ns, ops, options, callback) {
+ // Topology is not connected, save the call in the provided store to be
+ // Executed at some point when the handler deems it's reconnected
+ if(!this.isConnected() && this.s.disconnectHandler != null) {
+ callback = bindToCurrentDomain(callback);
+ return this.s.disconnectHandler.add('update', ns, ops, options, callback);
+ }
+
+ executeWriteOperation(this, 'update', ns, ops, options, callback);
+}
+
+/**
+ * Authenticate using a specified mechanism
+ * @method
+ * @param {string} mechanism The Auth mechanism we are invoking
+ * @param {string} db The db we are invoking the mechanism against
+ * @param {...object} param Parameters for the specific mechanism
+ * @param {authResultCallback} callback A callback function
+ */
+ReplSet.prototype.auth = function(mechanism, db) {
+ var allArgs = Array.prototype.slice.call(arguments, 0).slice(0);
+ var self = this;
+ var args = Array.prototype.slice.call(arguments, 2);
+ var callback = args.pop();
+
+ // If we don't have the mechanism fail
+ if(this.s.authProviders[mechanism] == null && mechanism != 'default')
+ throw new MongoError(f("auth provider %s does not exist", mechanism));
+
+ // Authenticate against all the servers
+ var servers = this.s.replState.getAll().slice(0);
+ var count = servers.length;
+ // Correct authentication
+ var authenticated = true;
+ var authErr = null;
+ // Set auth in progress
+ this.s.authInProgress = true;
+
+ // Authenticate against all servers
+ while(servers.length > 0) {
+ var server = servers.shift();
+
+ // Arguments without a callback
+ var argsWithoutCallback = [mechanism, db].concat(args.slice(0));
+ // Create arguments
+ var finalArguments = argsWithoutCallback.concat([function(err, r) {
+ count = count - 1;
+ if(err) authErr = err;
+ if(!r) authenticated = false;
+
+ // We are done
+ if(count == 0) {
+ // We have more servers that are not authenticated, let's authenticate
+ if(self.s.authInProgressServers.length > 0) {
+ self.s.authInProgressServers = [];
+ return self.auth.apply(self, [mechanism, db].concat(args).concat([callback]));
+ }
+
+ // Auth is done
+ self.s.authInProgress = false;
+ // Add successful credentials
+ if(authErr == null) addCredentials(self.s, db, argsWithoutCallback);
+ // Return the auth error
+ if(authErr) return callback(authErr, false);
+ // Successfully authenticated session
+ callback(null, new Session({}, self));
+ }
+ }]);
+
+ // Execute the auth
+ server.auth.apply(server, finalArguments);
+ }
+}
+
+ReplSet.prototype.state = function() {
+ return this.s.replState.state;
+}
+
+/**
+ * Initiate server connect
+ * @method
+ */
+ReplSet.prototype.connect = function(_options) {
+ var self = this;
+ // Start replicaset inquiry process
+ setTimeout(replicasetInquirer(this, this.s, false), this.s.haInterval);
+ // Additional options
+ if(_options) for(var name in _options) this.s.options[name] = _options[name];
+
+ // Set the state as connecting
+ this.s.replState.state = CONNECTING;
+
+ // No fullsetup reached
+ this.s.fullsetup = false;
+
+ // For all entries in the seedlist build a server instance
+ this.s.seedlist.forEach(function(e) {
+ // Clone options
+ var opts = cloneOptions(self.s.options);
+ // Add host and port
+ opts.host = e.host;
+ opts.port = e.port;
+ opts.reconnect = false;
+ opts.readPreferenceStrategies = self.s.readPreferenceStrategies;
+ opts.emitError = true;
+ if(self.s.tag) opts.tag = self.s.tag;
+ // Share the auth store
+ opts.authProviders = self.s.authProviders;
+ // Create a new Server
+ var server = new Server(opts);
+ // Add to list of disconnected servers
+ self.s.disconnectedServers.push(server);
+ // Add to list of inflight Connections
+ self.s.initialConnectionServers.push(server);
+ });
+
+ // Attempt to connect to all the servers
+ while(this.s.disconnectedServers.length > 0) {
+ // Get the server
+ var server = this.s.disconnectedServers.shift();
+
+ // Set up the event handlers
+ server.once('error', errorHandlerTemp(this, this.s, 'error'));
+ server.once('close', errorHandlerTemp(this, this.s, 'close'));
+ server.once('timeout', errorHandlerTemp(this, this.s, 'timeout'));
+ server.once('connect', connectHandler(this, this.s));
+
+ // Attempt to connect
+ server.connect();
+ }
+}
+
+/**
+ * Figure out if the server is connected
+ * @method
+ * @return {boolean}
+ */
+ReplSet.prototype.isConnected = function(options) {
+ options = options || {};
+ // If we specified a read preference check if we are connected to something
+ // than can satisfy this
+ if(options.readPreference
+ && options.readPreference.equals(ReadPreference.secondary))
+ return this.s.replState.isSecondaryConnected();
+
+ if(options.readPreference
+ && options.readPreference.equals(ReadPreference.primary))
+ return this.s.replState.isSecondaryConnected() || this.s.replState.isPrimaryConnected();
+
+ if(this.s.secondaryOnlyConnectionAllowed) return this.s.replState.isSecondaryConnected();
+ return this.s.replState.isPrimaryConnected();
+}
+
+/**
+ * Destroy the server connection
+ * @method
+ */
+ReplSet.prototype.destroy = function(emitClose) {
+ var self = this;
+ if(this.s.logger.isInfo()) this.s.logger.info(f('[%s] destroyed', this.s.id));
+ this.s.replState.state = DESTROYED;
+
+ // Emit close
+ if(emitClose && self.listeners('close').length > 0) self.emit('close', self);
+
+ // Destroy state
+ this.s.replState.destroy();
+
+ // Clear out any listeners
+ var events = ['timeout', 'error', 'close', 'joined', 'left'];
+ events.forEach(function(e) {
+ self.removeAllListeners(e);
+ });
+}
+
+/**
+ * A replset connect event, used to verify that the connection is up and running
+ *
+ * @event ReplSet#connect
+ * @type {ReplSet}
+ */
+
+/**
+ * The replset high availability event
+ *
+ * @event ReplSet#ha
+ * @type {function}
+ * @param {string} type The stage in the high availability event (start|end)
+ * @param {boolean} data.norepeat This is a repeating high availability process or a single execution only
+ * @param {number} data.id The id for this high availability request
+ * @param {object} data.state An object containing the information about the current replicaset
+ */
+
+/**
+ * A server member left the replicaset
+ *
+ * @event ReplSet#left
+ * @type {function}
+ * @param {string} type The type of member that left (primary|secondary|arbiter)
+ * @param {Server} server The server object that left
+ */
+
+/**
+ * A server member joined the replicaset
+ *
+ * @event ReplSet#joined
+ * @type {function}
+ * @param {string} type The type of member that joined (primary|secondary|arbiter)
+ * @param {Server} server The server object that joined
+ */
+
+//
+// Inquires about state changes
+//
+
+// Add the new credential for a db, removing the old
+// credential from the cache
+var addCredentials = function(s, db, argsWithoutCallback) {
+ // Remove any credentials for the db
+ clearCredentials(s, db + ".dummy");
+ // Add new credentials to list
+ s.credentials.push(argsWithoutCallback);
+}
+
+// Clear out credentials for a namespace
+var clearCredentials = function(s, ns) {
+ var db = ns.split('.')[0];
+ var filteredCredentials = [];
+
+ // Filter out all credentials for the db the user is logging out off
+ for(var i = 0; i < s.credentials.length; i++) {
+ if(s.credentials[i][1] != db) filteredCredentials.push(s.credentials[i]);
+ }
+
+ // Set new list of credentials
+ s.credentials = filteredCredentials;
+}
+
+//
+// Filter serves by tags
+var filterByTags = function(readPreference, servers) {
+ if(readPreference.tags == null) return servers;
+ var filteredServers = [];
+ var tags = readPreference.tags;
+
+ // Iterate over all the servers
+ for(var i = 0; i < servers.length; i++) {
+ var serverTag = servers[i].lastIsMaster().tags || {};
+ // Did we find the a matching server
+ var found = true;
+ // Check if the server is valid
+ for(var name in tags) {
+ if(serverTag[name] != tags[name]) found = false;
+ }
+
+ // Add to candidate list
+ if(found) filteredServers.push(servers[i]);
+ }
+
+ // Returned filtered servers
+ return filteredServers;
+}
+
+//
+// Pick a server based on readPreference
+var pickServer = function(self, s, readPreference) {
+ // If no read Preference set to primary by default
+ readPreference = readPreference || ReadPreference.primary;
+
+ // Do we have a custom readPreference strategy, use it
+ if(s.readPreferenceStrategies != null && s.readPreferenceStrategies[readPreference.preference] != null) {
+ if(s.readPreferenceStrategies[readPreference.preference] == null) throw new MongoError(f("cannot locate read preference handler for %s", readPreference.preference));
+ var server = s.readPreferenceStrategies[readPreference.preference].pickServer(s.replState, readPreference);
+ if(s.debug) self.emit('pickedServer', readPreference, server);
+ return server;
+ }
+
+ // Check if we can satisfy and of the basic read Preferences
+ if(readPreference.equals(ReadPreference.secondary)
+ && s.replState.secondaries.length == 0)
+ throw new MongoError("no secondary server available");
+
+ if(readPreference.equals(ReadPreference.secondaryPreferred)
+ && s.replState.secondaries.length == 0
+ && s.replState.primary == null)
+ throw new MongoError("no secondary or primary server available");
+
+ if(readPreference.equals(ReadPreference.primary)
+ && s.replState.primary == null)
+ throw new MongoError("no primary server available");
+
+ // Secondary
+ if(readPreference.equals(ReadPreference.secondary)) {
+ s.index = (s.index + 1) % s.replState.secondaries.length;
+ return s.replState.secondaries[s.index];
+ }
+
+ // Secondary preferred
+ if(readPreference.equals(ReadPreference.secondaryPreferred)) {
+ if(s.replState.secondaries.length > 0) {
+ // Apply tags if present
+ var servers = filterByTags(readPreference, s.replState.secondaries);
+ // If have a matching server pick one otherwise fall through to primary
+ if(servers.length > 0) {
+ s.index = (s.index + 1) % servers.length;
+ return servers[s.index];
+ }
+ }
+
+ return s.replState.primary;
+ }
+
+ // Primary preferred
+ if(readPreference.equals(ReadPreference.primaryPreferred)) {
+ if(s.replState.primary) return s.replState.primary;
+
+ if(s.replState.secondaries.length > 0) {
+ // Apply tags if present
+ var servers = filterByTags(readPreference, s.replState.secondaries);
+ // If have a matching server pick one otherwise fall through to primary
+ if(servers.length > 0) {
+ s.index = (s.index + 1) % servers.length;
+ return servers[s.index];
+ }
+
+ // Throw error a we have not valid secondary or primary servers
+ throw new MongoError("no secondary or primary server available");
+ }
+ }
+
+ // Return the primary
+ return s.replState.primary;
+}
+
+var replicasetInquirer = function(self, state, norepeat) {
+ return function() {
+ if(state.replState.state == DESTROYED) return
+ // Process already running don't rerun
+ if(state.highAvailabilityProcessRunning) return;
+ // Started processes
+ state.highAvailabilityProcessRunning = true;
+ if(state.logger.isInfo()) state.logger.info(f('[%s] monitoring process running %s', state.id, JSON.stringify(state.replState)));
+
+ // Unique HA id to identify the current look running
+ var localHaId = state.haId++;
+
+ // Clean out any failed connection attempts
+ state.connectingServers = {};
+
+ // Controls if we are doing a single inquiry or repeating
+ norepeat = typeof norepeat == 'boolean' ? norepeat : false;
+
+ // If we have a primary and a disconnect handler, execute
+ // buffered operations
+ if(state.replState.isPrimaryConnected() && state.replState.isSecondaryConnected() && state.disconnectHandler) {
+ state.disconnectHandler.execute();
+ }
+
+ // Emit replicasetInquirer
+ self.emit('ha', 'start', {norepeat: norepeat, id: localHaId, state: state.replState ? state.replState.toJSON() : {}});
+
+ // Let's process all the disconnected servers
+ while(state.disconnectedServers.length > 0) {
+ // Get the first disconnected server
+ var server = state.disconnectedServers.shift();
+ if(state.logger.isInfo()) state.logger.info(f('[%s] monitoring attempting to connect to %s', state.id, server.lastIsMaster() ? server.lastIsMaster().me : server.name));
+ // Set up the event handlers
+ server.once('error', errorHandlerTemp(self, state, 'error'));
+ server.once('close', errorHandlerTemp(self, state, 'close'));
+ server.once('timeout', errorHandlerTemp(self, state, 'timeout'));
+ server.once('connect', connectHandler(self, state));
+ // Attempt to connect
+ server.connect();
+ }
+
+ // Cleanup state (removed disconnected servers)
+ state.replState.clean();
+
+ // We need to query all servers
+ var servers = state.replState.getAll();
+ var serversLeft = servers.length;
+
+ // If no servers and we are not destroyed keep pinging
+ if(servers.length == 0 && state.replState.state == CONNECTED) {
+ // Emit ha process end
+ self.emit('ha', 'end', {norepeat: norepeat, id: localHaId, state: state.replState ? state.replState.toJSON() : {}});
+ // Ended highAvailabilityProcessRunning
+ state.highAvailabilityProcessRunning = false;
+ // Restart ha process
+ if(!norepeat) setTimeout(replicasetInquirer(self, state, false), state.haInterval);
+ return;
+ }
+
+ //
+ // ismaster for Master server
+ var primaryIsMaster = null;
+
+ //
+ // Inspect a specific servers ismaster
+ var inspectServer = function(server) {
+ if(state.replState.state == DESTROYED) return;
+ // Did we get a server
+ if(server && server.isConnected()) {
+ // Execute ismaster
+ server.command('system.$cmd', {ismaster:true}, function(err, r) {
+ if(state.replState.state == DESTROYED) return;
+ // Count down the number of servers left
+ serversLeft = serversLeft - 1;
+ // If we have an error but still outstanding server request return
+ if(err && serversLeft > 0) return;
+ // We had an error and have no more servers to inspect, schedule a new check
+ if(err && serversLeft == 0) {
+ self.emit('ha', 'end', {norepeat: norepeat, id: localHaId, state: state.replState ? state.replState.toJSON() : {}});
+ // Ended highAvailabilityProcessRunnfing
+ state.highAvailabilityProcessRunning = false;
+ // Return the replicasetInquirer
+ if(!norepeat) setTimeout(replicasetInquirer(self, state, false), state.haInterval);
+ return;
+ }
+
+ // Let all the read Preferences do things to the servers
+ var rPreferencesCount = Object.keys(state.readPreferenceStrategies).length;
+
+ // Handle the primary
+ var ismaster = r.result;
+ if(state.logger.isDebug()) state.logger.debug(f('[%s] monitoring process ismaster %s', state.id, JSON.stringify(ismaster)));
+
+ // Update the replicaset state
+ state.replState.update(ismaster, server);
+
+ // Add any new servers
+ if(err == null && ismaster.ismaster && Array.isArray(ismaster.hosts)) {
+ // Hosts to process
+ var hosts = ismaster.hosts;
+ // Add arbiters to list of hosts if we have any
+ if(Array.isArray(ismaster.arbiters)) hosts = hosts.concat(ismaster.arbiters);
+ if(Array.isArray(ismaster.passives)) hosts = hosts.concat(ismaster.passives);
+ // Process all the hsots
+ processHosts(self, state, hosts);
+ }
+
+ // No read Preferences strategies
+ if(rPreferencesCount == 0) {
+ // Don't schedule a new inquiry
+ if(serversLeft > 0) return;
+ // Emit ha process end
+ self.emit('ha', 'end', {norepeat: norepeat, id: localHaId, state: state.replState ? state.replState.toJSON() : {}});
+ // Ended highAvailabilityProcessRunning
+ state.highAvailabilityProcessRunning = false;
+ // Let's keep monitoring
+ if(!norepeat) setTimeout(replicasetInquirer(self, state, false), state.haInterval);
+ return;
+ }
+
+ // No servers left to query, execute read preference strategies
+ if(serversLeft == 0) {
+ // Go over all the read preferences
+ for(var name in state.readPreferenceStrategies) {
+ state.readPreferenceStrategies[name].ha(self, state.replState, function() {
+ rPreferencesCount = rPreferencesCount - 1;
+
+ if(rPreferencesCount == 0) {
+ // Add any new servers in primary ismaster
+ if(err == null
+ && ismaster.ismaster
+ && Array.isArray(ismaster.hosts)) {
+ processHosts(self, state, ismaster.hosts);
+ }
+
+ // Emit ha process end
+ self.emit('ha', 'end', {norepeat: norepeat, id: localHaId, state: state.replState ? state.replState.toJSON() : {}});
+ // Ended highAvailabilityProcessRunning
+ state.highAvailabilityProcessRunning = false;
+ // Let's keep monitoring
+ if(!norepeat) setTimeout(replicasetInquirer(self, state, false), state.haInterval);
+ return;
+ }
+ });
+ }
+ }
+ });
+ }
+ }
+
+ // Call ismaster on all servers
+ for(var i = 0; i < servers.length; i++) {
+ inspectServer(servers[i]);
+ }
+
+ // If no more initial servers and new scheduled servers to connect
+ if(state.replState.secondaries.length >= 1 && state.replState.primary != null && !state.fullsetup) {
+ state.fullsetup = true;
+ self.emit('fullsetup', self);
+ }
+
+ // If all servers are accounted for and we have not sent the all event
+ if(state.replState.primary != null && self.lastIsMaster()
+ && Array.isArray(self.lastIsMaster().hosts) && !state.all) {
+ var length = 1 + state.replState.secondaries.length;
+ if(length == self.lastIsMaster().hosts.length) {
+ state.all = true;
+ self.emit('all', self);
+ }
+ }
+ }
+}
+
+// Error handler for initial connect
+var errorHandlerTemp = function(self, state, event) {
+ return function(err, server) {
+ // Log the information
+ if(state.logger.isInfo()) state.logger.info(f('[%s] server %s disconnected', state.id, server.lastIsMaster() ? server.lastIsMaster().me : server.name));
+ // Filter out any connection servers
+ state.initialConnectionServers = state.initialConnectionServers.filter(function(_server) {
+ return server.name != _server.name;
+ });
+
+ // Connection is destroyed, ignore
+ if(state.replState.state == DESTROYED) return;
+
+ // Remove any non used handlers
+ ['error', 'close', 'timeout', 'connect'].forEach(function(e) {
+ server.removeAllListeners(e);
+ })
+
+ // Push to list of disconnected servers
+ addToListIfNotExist(state.disconnectedServers, server);
+
+ // End connection operation if we have no legal replicaset state
+ if(state.initialConnectionServers == 0 && state.replState.state == CONNECTING) {
+ if((state.secondaryOnlyConnectionAllowed && !state.replState.isSecondaryConnected() && !state.replState.isPrimaryConnected())
+ || (!state.secondaryOnlyConnectionAllowed && !state.replState.isPrimaryConnected())) {
+ if(state.logger.isInfo()) state.logger.info(f('[%s] no valid seed servers in list', state.id));
+
+ if(self.listeners('error').length > 0)
+ return self.emit('error', new MongoError('no valid seed servers in list'));
+ }
+ }
+
+ // If the number of disconnected servers is equal to
+ // the number of seed servers we cannot connect
+ if(state.disconnectedServers.length == state.seedlist.length && state.replState.state == CONNECTING) {
+ if(state.emitError && self.listeners('error').length > 0) {
+ if(state.logger.isInfo()) state.logger.info(f('[%s] no valid seed servers in list', state.id));
+
+ if(self.listeners('error').length > 0)
+ self.emit('error', new MongoError('no valid seed servers in list'));
+ }
+ }
+ }
+}
+
+// Connect handler
+var connectHandler = function(self, state) {
+ return function(server) {
+ if(state.logger.isInfo()) state.logger.info(f('[%s] connected to %s', state.id, server.name));
+ // Destroyed connection
+ if(state.replState.state == DESTROYED) {
+ server.destroy(false, false);
+ return;
+ }
+
+ // Filter out any connection servers
+ state.initialConnectionServers = state.initialConnectionServers.filter(function(_server) {
+ return server.name != _server.name;
+ });
+
+ // Process the new server
+ var processNewServer = function() {
+ // Discover any additional servers
+ var ismaster = server.lastIsMaster();
+
+ var events = ['error', 'close', 'timeout', 'connect', 'message'];
+ // Remove any non used handlers
+ events.forEach(function(e) {
+ server.removeAllListeners(e);
+ })
+
+ // Clean up
+ delete state.connectingServers[server.name];
+ // Update the replicaset state, destroy if not added
+ if(!state.replState.update(ismaster, server)) {
+ return server.destroy();
+ }
+
+ // Add the server handling code
+ if(server.isConnected()) {
+ server.on('error', errorHandler(self, state));
+ server.on('close', closeHandler(self, state));
+ server.on('timeout', timeoutHandler(self, state));
+ }
+
+ // Hosts to process
+ var hosts = ismaster.hosts;
+ // Add arbiters to list of hosts if we have any
+ if(Array.isArray(ismaster.arbiters)) hosts = hosts.concat(ismaster.arbiters);
+ if(Array.isArray(ismaster.passives)) hosts = hosts.concat(ismaster.passives);
+
+ // Add any new servers
+ processHosts(self, state, hosts);
+
+ // If have the server instance already destroy it
+ if(state.initialConnectionServers.length == 0 && Object.keys(state.connectingServers).length == 0
+ && !state.replState.isPrimaryConnected() && !state.secondaryOnlyConnectionAllowed && state.replState.state == CONNECTING) {
+ if(state.logger.isInfo()) state.logger.info(f('[%s] no primary found in replicaset', state.id));
+ self.emit('error', new MongoError("no primary found in replicaset"));
+ return self.destroy();
+ }
+
+ // If no more initial servers and new scheduled servers to connect
+ if(state.replState.secondaries.length >= 1 && state.replState.primary != null && !state.fullsetup) {
+ state.fullsetup = true;
+ self.emit('fullsetup', self);
+ }
+ }
+
+ // Save up new members to be authenticated against
+ if(self.s.authInProgress) {
+ self.s.authInProgressServers.push(server);
+ }
+
+ // No credentials just process server
+ if(state.credentials.length == 0) return processNewServer();
+ // Do we have credentials, let's apply them all
+ var count = state.credentials.length;
+ // Apply the credentials
+ for(var i = 0; i < state.credentials.length; i++) {
+ server.auth.apply(server, state.credentials[i].concat([function(err, r) {
+ count = count - 1;
+ if(count == 0) processNewServer();
+ }]));
+ }
+ }
+}
+
+//
+// Detect if we need to add new servers
+var processHosts = function(self, state, hosts) {
+ if(state.replState.state == DESTROYED) return;
+ if(Array.isArray(hosts)) {
+ // Check any hosts exposed by ismaster
+ for(var i = 0; i < hosts.length; i++) {
+ // If not found we need to create a new connection
+ if(!state.replState.contains(hosts[i])) {
+ if(state.connectingServers[hosts[i]] == null && !inInitialConnectingServers(self, state, hosts[i])) {
+ if(state.logger.isInfo()) state.logger.info(f('[%s] scheduled server %s for connection', state.id, hosts[i]));
+ // Make sure we know what is trying to connect
+ state.connectingServers[hosts[i]] = hosts[i];
+ // Connect the server
+ connectToServer(self, state, hosts[i].split(':')[0], parseInt(hosts[i].split(':')[1], 10));
+ }
+ }
+ }
+ }
+}
+
+var inInitialConnectingServers = function(self, state, address) {
+ for(var i = 0; i < state.initialConnectionServers.length; i++) {
+ if(state.initialConnectionServers[i].name == address) return true;
+ }
+ return false;
+}
+
+// Connect to a new server
+var connectToServer = function(self, state, host, port) {
+ var opts = cloneOptions(state.options);
+ opts.host = host;
+ opts.port = port;
+ opts.reconnect = false;
+ opts.readPreferenceStrategies = state.readPreferenceStrategies;
+ if(state.tag) opts.tag = state.tag;
+ // Share the auth store
+ opts.authProviders = state.authProviders;
+ opts.emitError = true;
+ // Create a new server instance
+ var server = new Server(opts);
+ // Set up the event handlers
+ server.once('error', errorHandlerTemp(self, state, 'error'));
+ server.once('close', errorHandlerTemp(self, state, 'close'));
+ server.once('timeout', errorHandlerTemp(self, state, 'timeout'));
+ server.once('connect', connectHandler(self, state));
+ // Attempt to connect
+ server.connect();
+}
+
+//
+// Add server to the list if it does not exist
+var addToListIfNotExist = function(list, server) {
+ var found = false;
+
+ // Remove any non used handlers
+ ['error', 'close', 'timeout', 'connect'].forEach(function(e) {
+ server.removeAllListeners(e);
+ })
+
+ // Check if the server already exists
+ for(var i = 0; i < list.length; i++) {
+ if(list[i].equals(server)) found = true;
+ }
+
+ if(!found) {
+ list.push(server);
+ }
+
+ return found;
+}
+
+var errorHandler = function(self, state) {
+ return function(err, server) {
+ if(state.replState.state == DESTROYED) return;
+ if(state.logger.isInfo()) state.logger.info(f('[%s] server %s errored out with %s', state.id, server.lastIsMaster() ? server.lastIsMaster().me : server.name, JSON.stringify(err)));
+ var found = addToListIfNotExist(state.disconnectedServers, server);
+ if(!found) self.emit('left', state.replState.remove(server), server);
+ if(found && state.emitError && self.listeners('error').length > 0) self.emit('error', err, server);
+
+ // Fire off a detection of missing server using minHeartbeatFrequencyMS
+ setTimeout(function() {
+ replicasetInquirer(self, self.s, true)();
+ }, self.s.minHeartbeatFrequencyMS);
+ }
+}
+
+var timeoutHandler = function(self, state) {
+ return function(err, server) {
+ if(state.replState.state == DESTROYED) return;
+ if(state.logger.isInfo()) state.logger.info(f('[%s] server %s timed out', state.id, server.lastIsMaster() ? server.lastIsMaster().me : server.name));
+ var found = addToListIfNotExist(state.disconnectedServers, server);
+ if(!found) self.emit('left', state.replState.remove(server), server);
+
+ // Fire off a detection of missing server using minHeartbeatFrequencyMS
+ setTimeout(function() {
+ replicasetInquirer(self, self.s, true)();
+ }, self.s.minHeartbeatFrequencyMS);
+ }
+}
+
+var closeHandler = function(self, state) {
+ return function(err, server) {
+ if(state.replState.state == DESTROYED) return;
+ if(state.logger.isInfo()) state.logger.info(f('[%s] server %s closed', state.id, server.lastIsMaster() ? server.lastIsMaster().me : server.name));
+ var found = addToListIfNotExist(state.disconnectedServers, server);
+ if(!found) self.emit('left', state.replState.remove(server), server);
+
+ // Fire off a detection of missing server using minHeartbeatFrequencyMS
+ setTimeout(function() {
+ replicasetInquirer(self, self.s, true)();
+ }, self.s.minHeartbeatFrequencyMS);
+ }
+}
+
+//
+// Validate if a non-master or recovering error
+var notMasterError = function(r) {
+ // Get result of any
+ var result = r && r.result ? r.result : r;
+
+ // Explore if we have a not master error
+ if(result && (result.err == 'not master'
+ || result.errmsg == 'not master' || (result['$err'] && result['$err'].indexOf('not master or secondary') != -1)
+ || (result['$err'] && result['$err'].indexOf("not master and slaveOk=false") != -1)
+ || result.errmsg == 'node is recovering')) {
+ return true;
+ }
+
+ return false;
+}
+
+module.exports = ReplSet;
diff --git a/server/node_modules/mongodb/node_modules/mongodb-core/lib/topologies/replset_state.js b/server/node_modules/mongodb/node_modules/mongodb-core/lib/topologies/replset_state.js
new file mode 100755
index 00000000..0b6237e5
--- /dev/null
+++ b/server/node_modules/mongodb/node_modules/mongodb-core/lib/topologies/replset_state.js
@@ -0,0 +1,421 @@
+"use strict";
+
+var Logger = require('../connection/logger')
+ , f = require('util').format
+ , MongoError = require('../error');
+
+var DISCONNECTED = 'disconnected';
+var CONNECTING = 'connecting';
+var CONNECTED = 'connected';
+var DESTROYED = 'destroyed';
+
+/**
+ * Creates a new Replicaset State object
+ * @class
+ * @property {object} primary Primary property
+ * @property {array} secondaries List of secondaries
+ * @property {array} arbiters List of arbiters
+ * @return {State} A cursor instance
+ */
+var State = function(replSet, options) {
+ this.replSet = replSet;
+ this.options = options;
+ this.secondaries = [];
+ this.arbiters = [];
+ this.passives = [];
+ this.primary = null;
+ // Initial state is disconnected
+ this.state = DISCONNECTED;
+ // Get a logger instance
+ this.logger = Logger('ReplSet', options);
+ // Unpacked options
+ this.id = options.id;
+ this.setName = options.setName;
+ this.connectingServers = options.connectingServers;
+ this.secondaryOnlyConnectionAllowed = options.secondaryOnlyConnectionAllowed;
+}
+
+/**
+ * Is there a secondary connected
+ * @method
+ * @return {boolean}
+ */
+State.prototype.isSecondaryConnected = function() {
+ for(var i = 0; i < this.secondaries.length; i++) {
+ if(this.secondaries[i].isConnected()) return true;
+ }
+
+ return false;
+}
+
+/**
+ * Is there a primary connection
+ * @method
+ * @return {boolean}
+ */
+State.prototype.isPrimaryConnected = function() {
+ return this.primary != null && this.primary.isConnected();
+}
+
+/**
+ * Is the given address the primary
+ * @method
+ * @param {string} address Server address
+ * @return {boolean}
+ */
+State.prototype.isPrimary = function(address) {
+ if(this.primary == null) return false;
+ return this.primary && this.primary.equals(address);
+}
+
+/**
+ * Is the given address a secondary
+ * @method
+ * @param {string} address Server address
+ * @return {boolean}
+ */
+State.prototype.isSecondary = function(address) {
+ // Check if the server is a secondary at the moment
+ for(var i = 0; i < this.secondaries.length; i++) {
+ if(this.secondaries[i].equals(address)) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+/**
+ * Is the given address a secondary
+ * @method
+ * @param {string} address Server address
+ * @return {boolean}
+ */
+State.prototype.isPassive = function(address) {
+ // Check if the server is a secondary at the moment
+ for(var i = 0; i < this.passives.length; i++) {
+ if(this.passives[i].equals(address)) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+/**
+ * Does the replicaset contain this server
+ * @method
+ * @param {string} address Server address
+ * @return {boolean}
+ */
+State.prototype.contains = function(address) {
+ if(this.primary && this.primary.equals(address)) return true;
+ for(var i = 0; i < this.secondaries.length; i++) {
+ if(this.secondaries[i].equals(address)) return true;
+ }
+
+ for(var i = 0; i < this.arbiters.length; i++) {
+ if(this.arbiters[i].equals(address)) return true;
+ }
+
+ for(var i = 0; i < this.passives.length; i++) {
+ if(this.passives[i].equals(address)) return true;
+ }
+
+ return false;
+}
+
+/**
+ * Clean out all dead connections
+ * @method
+ */
+State.prototype.clean = function() {
+ if(this.primary != null && !this.primary.isConnected()) {
+ this.primary = null;
+ }
+
+ // Filter out disconnected servers
+ this.secondaries = this.secondaries.filter(function(s) {
+ return s.isConnected();
+ });
+
+ // Filter out disconnected servers
+ this.arbiters = this.arbiters.filter(function(s) {
+ return s.isConnected();
+ });
+}
+
+/**
+ * Destroy state
+ * @method
+ */
+State.prototype.destroy = function() {
+ this.state = DESTROYED;
+ if(this.primary) this.primary.destroy();
+ this.secondaries.forEach(function(s) {
+ s.destroy();
+ });
+}
+
+/**
+ * Remove server from state
+ * @method
+ * @param {Server} Server to remove
+ * @return {string} Returns type of server removed (primary|secondary)
+ */
+State.prototype.remove = function(server) {
+ if(this.primary && this.primary.equals(server)) {
+ this.primary = null;
+ return 'primary';
+ }
+
+ var length = this.arbiters.length;
+ // Filter out the server from the arbiters
+ this.arbiters = this.arbiters.filter(function(s) {
+ return !s.equals(server);
+ });
+ if(this.arbiters.length < length) return 'arbiter';
+
+ var length = this.passives.length;
+ // Filter out the server from the passives
+ this.passives = this.passives.filter(function(s) {
+ return !s.equals(server);
+ });
+
+ // We have removed a passive
+ if(this.passives.length < length) {
+ // Ensure we removed it from the list of secondaries as well if it exists
+ this.secondaries = this.secondaries.filter(function(s) {
+ return !s.equals(server);
+ });
+
+ return 'passive';
+ }
+
+ // Filter out the server from the secondaries
+ this.secondaries = this.secondaries.filter(function(s) {
+ return !s.equals(server);
+ });
+
+ return 'secondary';
+}
+
+/**
+ * Get the server by name
+ * @method
+ * @param {string} address Server address
+ * @return {Server}
+ */
+State.prototype.get = function(server) {
+ var found = false;
+ // All servers to search
+ var servers = this.primary ? [this.primary] : [];
+ servers = servers.concat(this.secondaries);
+ // Locate the server
+ for(var i = 0; i < servers.length; i++) {
+ if(servers[i].equals(server)) {
+ return servers[i];
+ }
+ }
+}
+
+/**
+ * Get all the servers in the set
+ * @method
+ * @return {array}
+ */
+State.prototype.getAll = function() {
+ var servers = [];
+ if(this.primary) servers.push(this.primary);
+ return servers.concat(this.secondaries);
+}
+
+/**
+ * All raw connections
+ * @method
+ * @return {array}
+ */
+State.prototype.getAllConnections = function() {
+ var connections = [];
+ if(this.primary) connections = connections.concat(this.primary.connections());
+ this.secondaries.forEach(function(s) {
+ connections = connections.concat(s.connections());
+ })
+
+ return connections;
+}
+
+/**
+ * Return JSON object
+ * @method
+ * @return {object}
+ */
+State.prototype.toJSON = function() {
+ return {
+ primary: this.primary ? this.primary.lastIsMaster().me : null
+ , secondaries: this.secondaries.map(function(s) {
+ return s.lastIsMaster().me
+ })
+ }
+}
+
+/**
+ * Returns the last known ismaster document for this server
+ * @method
+ * @return {object}
+ */
+State.prototype.lastIsMaster = function() {
+ if(this.primary) return this.primary.lastIsMaster();
+ if(this.secondaries.length > 0) return this.secondaries[0].lastIsMaster();
+ return {};
+}
+
+/**
+ * Promote server to primary
+ * @method
+ * @param {Server} server Server we wish to promote
+ */
+State.prototype.promotePrimary = function(server) {
+ var currentServer = this.get(server);
+ // Server does not exist in the state, add it as new primary
+ if(currentServer == null) {
+ this.primary = server;
+ return;
+ }
+
+ // We found a server, make it primary and remove it from the secondaries
+ // Remove the server first
+ this.remove(currentServer);
+ // Set as primary
+ this.primary = currentServer;
+}
+
+var add = function(list, server) {
+ // Check if the server is a secondary at the moment
+ for(var i = 0; i < list.length; i++) {
+ if(list[i].equals(server)) return false;
+ }
+
+ list.push(server);
+ return true;
+}
+
+/**
+ * Add server to list of secondaries
+ * @method
+ * @param {Server} server Server we wish to add
+ */
+State.prototype.addSecondary = function(server) {
+ return add(this.secondaries, server);
+}
+
+/**
+ * Add server to list of arbiters
+ * @method
+ * @param {Server} server Server we wish to add
+ */
+State.prototype.addArbiter = function(server) {
+ return add(this.arbiters, server);
+}
+
+/**
+ * Add server to list of passives
+ * @method
+ * @param {Server} server Server we wish to add
+ */
+State.prototype.addPassive = function(server) {
+ return add(this.passives, server);
+}
+
+/**
+ * Update the state given a specific ismaster result
+ * @method
+ * @param {object} ismaster IsMaster result
+ * @param {Server} server IsMaster Server source
+ */
+State.prototype.update = function(ismaster, server) {
+ var self = this;
+ // Not in a known connection valid state
+ if(!ismaster.ismaster && !ismaster.secondary && !ismaster.arbiterOnly) {
+ // Remove the state
+ var result = self.remove(server);
+ if(self.state == CONNECTED) {
+ if(self.logger.isInfo()) self.logger.info(f('[%s] removing %s from set', self.id, ismaster.me));
+ self.replSet.emit('left', self.remove(server), server);
+ }
+
+ return false;
+ }
+
+ // Set the setName if it's not set from the first server
+ if(self.setName == null && ismaster.setName) {
+ if(self.logger.isInfo()) self.logger.info(f('[%s] setting setName to %s', self.id, ismaster.setName));
+ self.setName = ismaster.setName;
+ }
+
+ // Check if the replicaset name matches the provided one
+ if(ismaster.setName && self.setName != ismaster.setName) {
+ if(self.logger.isError()) self.logger.error(f('[%s] server in replset %s is not part of the specified setName %s', self.id, ismaster.setName, self.setName));
+ self.remove(server);
+ self.replSet.emit('error', new MongoError("provided setName for Replicaset Connection does not match setName found in server seedlist"));
+ return false;
+ }
+
+ // Log information
+ if(self.logger.isInfo()) self.logger.info(f('[%s] updating replicaset state %s', self.id, JSON.stringify(this)));
+
+ // It's a master set it
+ if(ismaster.ismaster && self.setName == ismaster.setName && !self.isPrimary(ismaster.me)) {
+ self.promotePrimary(server);
+ if(self.logger.isInfo()) self.logger.info(f('[%s] promoting %s to primary', self.id, ismaster.me));
+ // Emit primary
+ self.replSet.emit('joined', 'primary', this.primary);
+
+ // We are connected
+ if(self.state == CONNECTING) {
+ self.state = CONNECTED;
+ self.replSet.emit('connect', self.replSet);
+ } else {
+ self.state = CONNECTED;
+ self.replSet.emit('reconnect', server);
+ }
+ } else if(!ismaster.ismaster && self.setName == ismaster.setName
+ && ismaster.arbiterOnly) {
+ if(self.addArbiter(server)) {
+ if(self.logger.isInfo()) self.logger.info(f('[%s] promoting %s to arbiter', self.id, ismaster.me));
+ self.replSet.emit('joined', 'arbiter', server);
+ return true;
+ };
+
+ return false;
+ } else if(!ismaster.ismaster && self.setName == ismaster.setName
+ && ismaster.secondary && ismaster.passive) {
+ if(self.addPassive(server) && self.addSecondary(server)) {
+ if(self.logger.isInfo()) self.logger.info(f('[%s] promoting %s to passive', self.id, ismaster.me));
+ self.replSet.emit('joined', 'passive', server);
+ return true;
+ };
+
+ return false;
+ } else if(!ismaster.ismaster && self.setName == ismaster.setName
+ && ismaster.secondary) {
+ if(self.addSecondary(server)) {
+ if(self.logger.isInfo()) self.logger.info(f('[%s] promoting %s to passive', self.id, ismaster.me));
+ self.replSet.emit('joined', 'secondary', server);
+
+ if(self.secondaryOnlyConnectionAllowed && self.state == CONNECTING) {
+ self.state = CONNECTED;
+ self.replSet.emit('connect', self.replSet);
+ }
+
+ return true;
+ };
+
+ return false;
+ }
+
+ // Return update applied
+ return true;
+}
+
+module.exports = State;
diff --git a/server/node_modules/mongodb/node_modules/mongodb-core/lib/topologies/server.js b/server/node_modules/mongodb/node_modules/mongodb-core/lib/topologies/server.js
new file mode 100755
index 00000000..875d304b
--- /dev/null
+++ b/server/node_modules/mongodb/node_modules/mongodb-core/lib/topologies/server.js
@@ -0,0 +1,1074 @@
+ "use strict";
+
+var inherits = require('util').inherits
+ , f = require('util').format
+ , bindToCurrentDomain = require('../connection/utils').bindToCurrentDomain
+ , EventEmitter = require('events').EventEmitter
+ , Pool = require('../connection/pool')
+ , b = require('bson')
+ , Query = require('../connection/commands').Query
+ , MongoError = require('../error')
+ , ReadPreference = require('./read_preference')
+ , BasicCursor = require('../cursor')
+ , CommandResult = require('./command_result')
+ , getSingleProperty = require('../connection/utils').getSingleProperty
+ , getProperty = require('../connection/utils').getProperty
+ , debugOptions = require('../connection/utils').debugOptions
+ , BSON = require('bson').native().BSON
+ , PreTwoSixWireProtocolSupport = require('../wireprotocol/2_4_support')
+ , TwoSixWireProtocolSupport = require('../wireprotocol/2_6_support')
+ , Session = require('./session')
+ , Logger = require('../connection/logger')
+ , MongoCR = require('../auth/mongocr')
+ , X509 = require('../auth/x509')
+ , Plain = require('../auth/plain')
+ , GSSAPI = require('../auth/gssapi')
+ , SSPI = require('../auth/sspi')
+ , ScramSHA1 = require('../auth/scram');
+
+/**
+ * @fileOverview The **Server** class is a class that represents a single server topology and is
+ * used to construct connections.
+ *
+ * @example
+ * var Server = require('mongodb-core').Server
+ * , ReadPreference = require('mongodb-core').ReadPreference
+ * , assert = require('assert');
+ *
+ * var server = new Server({host: 'localhost', port: 27017});
+ * // Wait for the connection event
+ * server.on('connect', function(server) {
+ * server.destroy();
+ * });
+ *
+ * // Start connecting
+ * server.connect();
+ */
+
+// All bson types
+var bsonTypes = [b.Long, b.ObjectID, b.Binary, b.Code, b.DBRef, b.Symbol, b.Double, b.Timestamp, b.MaxKey, b.MinKey];
+// BSON parser
+var bsonInstance = null;
+// Server instance id
+var serverId = 0;
+// Callbacks instance id
+var callbackId = 0;
+
+// Single store for all callbacks
+var Callbacks = function() {
+ // EventEmitter.call(this);
+ var self = this;
+ // Callbacks
+ this.callbacks = {};
+ // Set the callbacks id
+ this.id = callbackId++;
+ // Set the type to server
+ this.type = 'server';
+}
+
+//
+// Flush all callbacks
+Callbacks.prototype.flush = function(err) {
+ for(var id in this.callbacks) {
+ if(!isNaN(parseInt(id, 10))) {
+ var callback = this.callbacks[id];
+ delete this.callbacks[id];
+ callback(err, null);
+ }
+ }
+}
+
+Callbacks.prototype.emit = function(id, err, value) {
+ var callback = this.callbacks[id];
+ delete this.callbacks[id];
+ callback(err, value);
+}
+
+Callbacks.prototype.raw = function(id) {
+ if(this.callbacks[id] == null) return false;
+ return this.callbacks[id].raw == true ? true : false
+}
+
+Callbacks.prototype.unregister = function(id) {
+ delete this.callbacks[id];
+}
+
+Callbacks.prototype.register = function(id, callback) {
+ this.callbacks[id] = bindToCurrentDomain(callback);
+}
+
+/**
+ * @ignore
+ */
+var bindToCurrentDomain = function(callback) {
+ var domain = process.domain;
+ if(domain == null || callback == null) return callback;
+ return domain.bind(callback);
+}
+
+var DISCONNECTED = 'disconnected';
+var CONNECTING = 'connecting';
+var CONNECTED = 'connected';
+var DESTROYED = 'destroyed';
+
+// Supports server
+var supportsServer = function(_s) {
+ return _s.ismaster && typeof _s.ismaster.minWireVersion == 'number';
+}
+
+//
+// createWireProtocolHandler
+var createWireProtocolHandler = function(result) {
+ // 2.6 wire protocol handler
+ if(result && result.maxWireVersion >= 2) {
+ return new TwoSixWireProtocolSupport();
+ }
+
+ // 2.4 or earlier wire protocol handler
+ return new PreTwoSixWireProtocolSupport();
+}
+
+//
+// Reconnect server
+var reconnectServer = function(self, state) {
+ // If the current reconnect retries is 0 stop attempting to reconnect
+ if(state.currentReconnectRetry == 0) {
+ return self.destroy(true, true);
+ }
+
+ // Adjust the number of retries
+ state.currentReconnectRetry = state.currentReconnectRetry - 1;
+
+ // Set status to connecting
+ state.state = CONNECTING;
+ // Create a new Pool
+ state.pool = new Pool(state.options);
+ // error handler
+ var reconnectErrorHandler = function(err) {
+ state.state = DISCONNECTED;
+ // Destroy the pool
+ state.pool.destroy();
+ // Adjust the number of retries
+ state.currentReconnectRetry = state.currentReconnectRetry - 1;
+ // No more retries
+ if(state.currentReconnectRetry <= 0) {
+ self.emit('error', f('failed to connect to %s:%s after %s retries', state.options.host, state.options.port, state.reconnectTries));
+ } else {
+ setTimeout(function() {
+ reconnectServer(self, state);
+ }, state.reconnectInterval);
+ }
+ }
+
+ //
+ // Attempt to connect
+ state.pool.once('connect', function() {
+ // Remove any non used handlers
+ var events = ['error', 'close', 'timeout', 'parseError'];
+ events.forEach(function(e) {
+ state.pool.removeAllListeners(e);
+ });
+
+ // Set connected state
+ state.state = CONNECTED;
+
+ // Add proper handlers
+ state.pool.once('error', reconnectErrorHandler);
+ state.pool.once('close', closeHandler(self, state));
+ state.pool.once('timeout', timeoutHandler(self, state));
+ state.pool.once('parseError', fatalErrorHandler(self, state));
+
+ // We need to ensure we have re-authenticated
+ var keys = Object.keys(state.authProviders);
+ if(keys.length == 0) return self.emit('reconnect', self);
+
+ // Execute all providers
+ var count = keys.length;
+ // Iterate over keys
+ for(var i = 0; i < keys.length; i++) {
+ state.authProviders[keys[i]].reauthenticate(self, state.pool, function(err, r) {
+ count = count - 1;
+ // We are done, emit reconnect event
+ if(count == 0) {
+ return self.emit('reconnect', self);
+ }
+ });
+ }
+ });
+
+ //
+ // Handle connection failure
+ state.pool.once('error', errorHandler(self, state));
+ state.pool.once('close', errorHandler(self, state));
+ state.pool.once('timeout', errorHandler(self, state));
+ state.pool.once('parseError', errorHandler(self, state));
+
+ // Connect pool
+ state.pool.connect();
+}
+
+//
+// Handlers
+var messageHandler = function(self, state) {
+ return function(response, connection) {
+ try {
+ // Parse the message
+ response.parse({raw: state.callbacks.raw(response.responseTo)});
+ if(state.logger.isDebug()) state.logger.debug(f('message [%s] received from %s', response.raw.toString('hex'), self.name));
+ state.callbacks.emit(response.responseTo, null, response);
+ } catch (err) {
+ state.callbacks.flush(new MongoError(err));
+ self.destroy();
+ }
+ }
+}
+
+var errorHandler = function(self, state) {
+ return function(err, connection) {
+ if(state.state == DISCONNECTED || state.state == DESTROYED) return;
+ // Set disconnected state
+ state.state = DISCONNECTED;
+ if(state.readPreferenceStrategies != null) notifyStrategies(self, self.s, 'error', [self]);
+ if(state.logger.isInfo()) state.logger.info(f('server %s errored out with %s', self.name, JSON.stringify(err)));
+ // Flush out all the callbacks
+ if(state.callbacks) state.callbacks.flush(new MongoError(f("server %s received an error %s", self.name, JSON.stringify(err))));
+ // Destroy all connections
+ self.destroy();
+ // Emit error event
+ if(state.emitError && self.listeners('error').length > 0) self.emit('error', err, self);
+ // If we specified the driver to reconnect perform it
+ if(state.reconnect) setTimeout(function() {
+ // state.currentReconnectRetry = state.reconnectTries,
+ reconnectServer(self, state)
+ }, state.reconnectInterval);
+ }
+}
+
+var fatalErrorHandler = function(self, state) {
+ return function(err, connection) {
+ if(state.state == DISCONNECTED || state.state == DESTROYED) return;
+ // Set disconnected state
+ state.state = DISCONNECTED;
+
+ if(state.readPreferenceStrategies != null) notifyStrategies(self, self.s, 'error', [self]);
+ if(state.logger.isInfo()) state.logger.info(f('server %s errored out with %s', self.name, JSON.stringify(err)));
+ // Flush out all the callbacks
+ if(state.callbacks) state.callbacks.flush(new MongoError(f("server %s received an error %s", self.name, JSON.stringify(err))));
+ // Emit error event
+ self.emit('error', err, self);
+ // If we specified the driver to reconnect perform it
+ if(state.reconnect) setTimeout(function() {
+ // state.currentReconnectRetry = state.reconnectTries,
+ reconnectServer(self, state)
+ }, state.reconnectInterval);
+ // Destroy all connections
+ self.destroy();
+ }
+}
+
+var timeoutHandler = function(self, state) {
+ return function(err, connection) {
+ if(state.state == DISCONNECTED || state.state == DESTROYED) return;
+ // Set disconnected state
+ state.state = DISCONNECTED;
+
+ if(state.readPreferenceStrategies != null) notifyStrategies(self, self.s, 'timeout', [self]);
+ if(state.logger.isInfo()) state.logger.info(f('server %s timed out', self.name));
+ // Flush out all the callbacks
+ if(state.callbacks) state.callbacks.flush(new MongoError(f("server %s timed out", self.name)));
+ // Emit error event
+ self.emit('timeout', err, self);
+ // If we specified the driver to reconnect perform it
+ if(state.reconnect) setTimeout(function() {
+ // state.currentReconnectRetry = state.reconnectTries,
+ reconnectServer(self, state)
+ }, state.reconnectInterval);
+ // Destroy all connections
+ self.destroy();
+ }
+}
+
+var closeHandler = function(self, state) {
+ return function(err, connection) {
+ if(state.state == DISCONNECTED || state.state == DESTROYED) return;
+ // Set disconnected state
+ state.state = DISCONNECTED;
+
+ if(state.readPreferenceStrategies != null) notifyStrategies(self, self.s, 'close', [self]);
+ if(state.logger.isInfo()) state.logger.info(f('server %s closed', self.name));
+ // Flush out all the callbacks
+ if(state.callbacks) state.callbacks.flush(new MongoError(f("server %s sockets closed", self.name)));
+ // Emit error event
+ self.emit('close', err, self);
+ // If we specified the driver to reconnect perform it
+ if(state.reconnect) setTimeout(function() {
+ // state.currentReconnectRetry = state.reconnectTries,
+ reconnectServer(self, state)
+ }, state.reconnectInterval);
+ // Destroy all connections
+ self.destroy();
+ }
+}
+
+var connectHandler = function(self, state) {
+ // Reset retries
+ state.currentReconnectRetry = state.reconnectTries;
+ // Apply all stored authentications
+ var applyAuthentications = function(callback) {
+ // We need to ensure we have re-authenticated
+ var keys = Object.keys(state.authProviders);
+ if(keys.length == 0) return callback(null, null);
+
+ // Execute all providers
+ var count = keys.length;
+ // Iterate over keys
+ for(var i = 0; i < keys.length; i++) {
+ state.authProviders[keys[i]].reauthenticate(self, state.pool, function(err, r) {
+ count = count - 1;
+ // We are done, emit reconnect event
+ if(count == 0) {
+ return callback(null, null);
+ }
+ });
+ }
+ }
+
+ return function(connection) {
+ // Apply any applyAuthentications
+ applyAuthentications(function() {
+
+ // Execute an ismaster
+ self.command('system.$cmd', {ismaster:true}, function(err, r) {
+ if(err) {
+ state.state = DISCONNECTED;
+ return self.emit('close', err, self);
+ }
+
+ // Set the current ismaster
+ if(!err) {
+ state.ismaster = r.result;
+ }
+
+ // Determine the wire protocol handler
+ state.wireProtocolHandler = createWireProtocolHandler(state.ismaster);
+
+ // Set the wireProtocolHandler
+ state.options.wireProtocolHandler = state.wireProtocolHandler;
+
+ // Log the ismaster if available
+ if(state.logger.isInfo()) state.logger.info(f('server %s connected with ismaster [%s]', self.name, JSON.stringify(r.result)));
+
+ // Validate if we it's a server we can connect to
+ if(!supportsServer(state) && state.wireProtocolHandler == null) {
+ state.state = DISCONNECTED
+ return self.emit('error', new MongoError("non supported server version"), self);
+ }
+
+ // Set the details
+ if(state.ismaster && state.ismaster.me) state.serverDetails.name = state.ismaster.me;
+
+ // No read preference strategies just emit connect
+ if(state.readPreferenceStrategies == null) {
+ state.state = CONNECTED;
+ return self.emit('connect', self);
+ }
+
+ // Signal connect to all readPreferences
+ notifyStrategies(self, self.s, 'connect', [self], function(err, result) {
+ state.state = CONNECTED;
+ return self.emit('connect', self);
+ });
+ });
+ });
+ }
+}
+
+var slaveOk = function(r) {
+ if(r) return r.slaveOk()
+ return false;
+}
+
+//
+// Execute readPreference Strategies
+var notifyStrategies = function(self, state, op, params, callback) {
+ if(typeof callback != 'function') {
+ // Notify query start to any read Preference strategies
+ for(var name in state.readPreferenceStrategies) {
+ if(state.readPreferenceStrategies[name][op]) {
+ var strat = state.readPreferenceStrategies[name];
+ strat[op].apply(strat, params);
+ }
+ }
+ // Finish up
+ return;
+ }
+
+ // Execute the async callbacks
+ var nPreferences = Object.keys(state.readPreferenceStrategies).length;
+ if(nPreferences == 0) return callback(null, null);
+ for(var name in state.readPreferenceStrategies) {
+ if(state.readPreferenceStrategies[name][op]) {
+ var strat = state.readPreferenceStrategies[name];
+ // Add a callback to params
+ var cParams = params.slice(0);
+ cParams.push(function(err, r) {
+ nPreferences = nPreferences - 1;
+ if(nPreferences == 0) {
+ callback(null, null);
+ }
+ })
+ // Execute the readPreference
+ strat[op].apply(strat, cParams);
+ }
+ }
+}
+
+var debugFields = ['reconnect', 'reconnectTries', 'reconnectInterval', 'emitError', 'cursorFactory', 'host'
+ , 'port', 'size', 'keepAlive', 'keepAliveInitialDelay', 'noDelay', 'connectionTimeout'
+ , 'socketTimeout', 'singleBufferSerializtion', 'ssl', 'ca', 'cert', 'key', 'rejectUnauthorized', 'promoteLongs'];
+
+/**
+ * Creates a new Server instance
+ * @class
+ * @param {boolean} [options.reconnect=true] Server will attempt to reconnect on loss of connection
+ * @param {number} [options.reconnectTries=30] Server attempt to reconnect #times
+ * @param {number} [options.reconnectInterval=1000] Server will wait # milliseconds between retries
+ * @param {boolean} [options.emitError=false] Server will emit errors events
+ * @param {Cursor} [options.cursorFactory=Cursor] The cursor factory class used for all query cursors
+ * @param {string} options.host The server host
+ * @param {number} options.port The server port
+ * @param {number} [options.size=5] Server connection pool size
+ * @param {boolean} [options.keepAlive=true] TCP Connection keep alive enabled
+ * @param {number} [options.keepAliveInitialDelay=0] Initial delay before TCP keep alive enabled
+ * @param {boolean} [options.noDelay=true] TCP Connection no delay
+ * @param {number} [options.connectionTimeout=0] TCP Connection timeout setting
+ * @param {number} [options.socketTimeout=0] TCP Socket timeout setting
+ * @param {boolean} [options.singleBufferSerializtion=true] Serialize into single buffer, trade of peak memory for serialization speed
+ * @param {boolean} [options.ssl=false] Use SSL for connection
+ * @param {Buffer} [options.ca] SSL Certificate store binary buffer
+ * @param {Buffer} [options.cert] SSL Certificate binary buffer
+ * @param {Buffer} [options.key] SSL Key file binary buffer
+ * @param {string} [options.passphrase] SSL Certificate pass phrase
+ * @param {boolean} [options.rejectUnauthorized=true] Reject unauthorized server certificates
+ * @param {boolean} [options.promoteLongs=true] Convert Long values from the db into Numbers if they fit into 53 bits
+ * @return {Server} A cursor instance
+ * @fires Server#connect
+ * @fires Server#close
+ * @fires Server#error
+ * @fires Server#timeout
+ * @fires Server#parseError
+ * @fires Server#reconnect
+ */
+var Server = function(options) {
+ var self = this;
+
+ // Add event listener
+ EventEmitter.call(this);
+
+ // BSON Parser, ensure we have a single instance
+ if(bsonInstance == null) {
+ bsonInstance = new BSON(bsonTypes);
+ }
+
+ // Reconnect retries
+ var reconnectTries = options.reconnectTries || 30;
+
+ // Keeps all the internal state of the server
+ this.s = {
+ // Options
+ options: options
+ // Contains all the callbacks
+ , callbacks: new Callbacks()
+ // Logger
+ , logger: Logger('Server', options)
+ // Server state
+ , state: DISCONNECTED
+ // Reconnect option
+ , reconnect: typeof options.reconnect == 'boolean' ? options.reconnect : true
+ , reconnectTries: reconnectTries
+ , reconnectInterval: options.reconnectInterval || 1000
+ // Swallow or emit errors
+ , emitError: typeof options.emitError == 'boolean' ? options.emitError : false
+ // Current state
+ , currentReconnectRetry: reconnectTries
+ // Contains the ismaster
+ , ismaster: null
+ // Contains any alternate strategies for picking
+ , readPreferenceStrategies: options.readPreferenceStrategies
+ // Auth providers
+ , authProviders: options.authProviders || {}
+ // Server instance id
+ , id: serverId++
+ // Grouping tag used for debugging purposes
+ , tag: options.tag
+ // Do we have a not connected handler
+ , disconnectHandler: options.disconnectHandler
+ // wireProtocolHandler methods
+ , wireProtocolHandler: options.wireProtocolHandler || new PreTwoSixWireProtocolSupport()
+ // Factory overrides
+ , Cursor: options.cursorFactory || BasicCursor
+ // BSON Parser, ensure we have a single instance
+ , bsonInstance: bsonInstance
+ // Pick the right bson parser
+ , bson: options.bson ? options.bson : bsonInstance
+ // Internal connection pool
+ , pool: null
+ // Server details
+ , serverDetails: {
+ host: options.host
+ , port: options.port
+ , name: options.port ? f("%s:%s", options.host, options.port) : options.host
+ }
+ }
+
+ // Reference state
+ var s = this.s;
+
+ // Add bson parser to options
+ options.bson = s.bson;
+
+ // Set error properties
+ getProperty(this, 'name', 'name', s.serverDetails, {});
+ getProperty(this, 'bson', 'bson', s.options, {});
+ getProperty(this, 'wireProtocolHandler', 'wireProtocolHandler', s.options, {});
+ getSingleProperty(this, 'id', s.id);
+
+ // Add auth providers
+ this.addAuthProvider('mongocr', new MongoCR());
+ this.addAuthProvider('x509', new X509());
+ this.addAuthProvider('plain', new Plain());
+ this.addAuthProvider('gssapi', new GSSAPI());
+ this.addAuthProvider('sspi', new SSPI());
+ this.addAuthProvider('scram-sha-1', new ScramSHA1());
+}
+
+inherits(Server, EventEmitter);
+
+/**
+ * Execute a command
+ * @method
+ * @param {string} type Type of BSON parser to use (c++ or js)
+ */
+Server.prototype.setBSONParserType = function(type) {
+ var nBSON = null;
+
+ if(type == 'c++') {
+ nBSON = require('bson').native().BSON;
+ } else if(type == 'js') {
+ nBSON = require('bson').pure().BSON;
+ } else {
+ throw new MongoError(f("% parser not supported", type));
+ }
+
+ this.s.options.bson = new nBSON(bsonTypes);
+}
+
+/**
+ * Returns the last known ismaster document for this server
+ * @method
+ * @return {object}
+ */
+Server.prototype.lastIsMaster = function() {
+ return this.s.ismaster;
+}
+
+/**
+ * Initiate server connect
+ * @method
+ */
+Server.prototype.connect = function(_options) {
+ var self = this;
+ // Set server specific settings
+ _options = _options || {}
+ if(typeof _options.promoteLongs == 'boolean') {
+ self.s.options.promoteLongs = _options.promoteLongs;
+ }
+
+ // Destroy existing pool
+ if(self.s.pool) {
+ self.s.pool.destroy();
+ self.s.pool = null;
+ }
+
+ // Set the state to connection
+ self.s.state = CONNECTING;
+ // Create a new connection pool
+ if(!self.s.pool) {
+ self.s.options.messageHandler = messageHandler(self, self.s);
+ self.s.pool = new Pool(self.s.options);
+ }
+
+ // Add all the event handlers
+ self.s.pool.once('timeout', timeoutHandler(self, self.s));
+ self.s.pool.once('close', closeHandler(self, self.s));
+ self.s.pool.once('error', errorHandler(self, self.s));
+ self.s.pool.once('connect', connectHandler(self, self.s));
+ self.s.pool.once('parseError', fatalErrorHandler(self, self.s));
+
+ // Connect the pool
+ self.s.pool.connect();
+}
+
+/**
+ * Destroy the server connection
+ * @method
+ */
+Server.prototype.destroy = function(emitClose, emitDestroy) {
+ var self = this;
+ if(self.s.logger.isDebug()) self.s.logger.debug(f('destroy called on server %s', self.name));
+ // Emit close
+ if(emitClose && self.listeners('close').length > 0) self.emit('close', self);
+
+ // Emit destroy event
+ if(emitDestroy) self.emit('destroy', self);
+ // Set state as destroyed
+ self.s.state = DESTROYED;
+ // Close the pool
+ self.s.pool.destroy();
+ // Flush out all the callbacks
+ if(self.s.callbacks) self.s.callbacks.flush(new MongoError(f("server %s sockets closed", self.name)));
+}
+
+/**
+ * Figure out if the server is connected
+ * @method
+ * @return {boolean}
+ */
+Server.prototype.isConnected = function() {
+ var self = this;
+ if(self.s.pool) return self.s.pool.isConnected();
+ return false;
+}
+
+/**
+ * Execute a command
+ * @method
+ * @param {string} ns The MongoDB fully qualified namespace (ex: db1.collection1)
+ * @param {object} cmd The command hash
+ * @param {ReadPreference} [options.readPreference] Specify read preference if command supports it
+ * @param {Connection} [options.connection] Specify connection object to execute command against
+ * @param {opResultCallback} callback A callback function
+ */
+Server.prototype.command = function(ns, cmd, options, callback) {
+ var self = this;
+ if(typeof options == 'function') callback = options, options = {};
+ // Ensure we have no options
+ options = options || {};
+ // Do we have a read Preference it need to be of type ReadPreference
+ if(options.readPreference && !(options.readPreference instanceof ReadPreference)) {
+ throw new Error("readPreference must be an instance of ReadPreference");
+ }
+
+ // Debug log
+ if(self.s.logger.isDebug()) self.s.logger.debug(f('executing command [%s] against %s', JSON.stringify({
+ ns: ns, cmd: cmd, options: debugOptions(debugFields, options)
+ }), self.name));
+
+ // Topology is not connected, save the call in the provided store to be
+ // Executed at some point when the handler deems it's reconnected
+ if(!self.isConnected() && self.s.disconnectHandler != null) {
+ callback = bindToCurrentDomain(callback);
+ return self.s.disconnectHandler.add('command', ns, cmd, options, callback);
+ }
+
+ // If we have no connection error
+ if(!self.s.pool.isConnected()) return callback(new MongoError(f("no connection available to server %s", self.name)));
+
+ // Execute on all connections
+ var onAll = typeof options.onAll == 'boolean' ? options.onAll : false;
+
+ // Check keys
+ var checkKeys = typeof options.checkKeys == 'boolean' ? options.checkKeys: false;
+
+ // Serialize function
+ var serializeFunctions = typeof options.serializeFunctions == 'boolean' ? options.serializeFunctions : false;
+
+ // Query options
+ var queryOptions = {
+ numberToSkip: 0, numberToReturn: -1, checkKeys: checkKeys
+ };
+
+ if(serializeFunctions) queryOptions.serializeFunctions = serializeFunctions;
+
+ // Create a query instance
+ var query = new Query(self.s.bson, ns, cmd, queryOptions);
+
+ // Set slave OK
+ query.slaveOk = slaveOk(options.readPreference);
+
+ // Notify query start to any read Preference strategies
+ if(self.s.readPreferenceStrategies != null)
+ notifyStrategies(self, self.s, 'startOperation', [self, query, new Date()]);
+
+ // Get a connection (either passed or from the pool)
+ var connection = options.connection || self.s.pool.get();
+
+ // Double check if we have a valid connection
+ if(!connection.isConnected()) {
+ return callback(new MongoError(f("no connection available to server %s", self.name)));
+ }
+
+ // Print cmd and execution connection if in debug mode for logging
+ if(self.s.logger.isDebug()) {
+ var json = connection.toJSON();
+ self.s.logger.debug(f('cmd [%s] about to be executed on connection with id %s at %s:%s', JSON.stringify(cmd), json.id, json.host, json.port));
+ }
+
+ // Execute multiple queries
+ if(onAll) {
+ var connections = self.s.pool.getAll();
+ var total = connections.length;
+ // We have an error
+ var error = null;
+ // Execute on all connections
+ for(var i = 0; i < connections.length; i++) {
+ try {
+ query.incRequestId();
+ connections[i].write(query.toBin());
+ } catch(err) {
+ total = total - 1;
+ if(total == 0) return callback(MongoError.create(err));
+ }
+
+ // Register the callback
+ self.s.callbacks.register(query.requestId, function(err, result) {
+ if(err) error = err;
+ total = total - 1;
+
+ // Done
+ if(total == 0) {
+ // Notify end of command
+ notifyStrategies(self, self.s, 'endOperation', [self, error, result, new Date()]);
+ if(error) return callback(MongoError.create(error));
+ // Execute callback, catch and rethrow if needed
+ try { callback(null, new CommandResult(result.documents[0], connections)); }
+ catch(err) { process.nextTick(function() { throw err}); }
+ }
+ });
+ }
+
+ return;
+ }
+
+ // Execute a single command query
+ try {
+ connection.write(query.toBin());
+ } catch(err) {
+ return callback(MongoError.create(err));
+ }
+
+ // Register the callback
+ self.s.callbacks.register(query.requestId, function(err, result) {
+ // Notify end of command
+ notifyStrategies(self, self.s, 'endOperation', [self, err, result, new Date()]);
+ if(err) return callback(err);
+ if(result.documents[0]['$err']
+ || result.documents[0]['errmsg']
+ || result.documents[0]['err']
+ || result.documents[0]['code']) return callback(MongoError.create(result.documents[0]));
+ // Execute callback, catch and rethrow if needed
+ try { callback(null, new CommandResult(result.documents[0], connection)); }
+ catch(err) { process.nextTick(function() { throw err}); }
+ });
+}
+
+/**
+ * Insert one or more documents
+ * @method
+ * @param {string} ns The MongoDB fully qualified namespace (ex: db1.collection1)
+ * @param {array} ops An array of documents to insert
+ * @param {boolean} [options.ordered=true] Execute in order or out of order
+ * @param {object} [options.writeConcern={}] Write concern for the operation
+ * @param {opResultCallback} callback A callback function
+ */
+Server.prototype.insert = function(ns, ops, options, callback) {
+ var self = this;
+ // Topology is not connected, save the call in the provided store to be
+ // Executed at some point when the handler deems it's reconnected
+ if(!self.isConnected() && self.s.disconnectHandler != null) {
+ callback = bindToCurrentDomain(callback);
+ return self.s.disconnectHandler.add('insert', ns, ops, options, callback);
+ }
+
+ // Setup the docs as an array
+ ops = Array.isArray(ops) ? ops : [ops];
+ // Execute write
+ return self.s.wireProtocolHandler.insert(self, self.s.ismaster, ns, self.s.bson, self.s.pool, self.s.callbacks, ops, options, callback);
+}
+
+/**
+ * Perform one or more update operations
+ * @method
+ * @param {string} ns The MongoDB fully qualified namespace (ex: db1.collection1)
+ * @param {array} ops An array of updates
+ * @param {boolean} [options.ordered=true] Execute in order or out of order
+ * @param {object} [options.writeConcern={}] Write concern for the operation
+ * @param {opResultCallback} callback A callback function
+ */
+Server.prototype.update = function(ns, ops, options, callback) {
+ var self = this;
+ // Topology is not connected, save the call in the provided store to be
+ // Executed at some point when the handler deems it's reconnected
+ if(!self.isConnected() && self.s.disconnectHandler != null) {
+ callback = bindToCurrentDomain(callback);
+ return self.s.disconnectHandler.add('update', ns, ops, options, callback);
+ }
+
+ // Setup the docs as an array
+ ops = Array.isArray(ops) ? ops : [ops];
+ // Execute write
+ return self.s.wireProtocolHandler.update(self, self.s.ismaster, ns, self.s.bson, self.s.pool, self.s.callbacks, ops, options, callback);
+}
+
+/**
+ * Perform one or more remove operations
+ * @method
+ * @param {string} ns The MongoDB fully qualified namespace (ex: db1.collection1)
+ * @param {array} ops An array of removes
+ * @param {boolean} [options.ordered=true] Execute in order or out of order
+ * @param {object} [options.writeConcern={}] Write concern for the operation
+ * @param {opResultCallback} callback A callback function
+ */
+Server.prototype.remove = function(ns, ops, options, callback) {
+ var self = this;
+ // Topology is not connected, save the call in the provided store to be
+ // Executed at some point when the handler deems it's reconnected
+ if(!self.isConnected() && self.s.disconnectHandler != null) {
+ callback = bindToCurrentDomain(callback);
+ return self.s.disconnectHandler.add('remove', ns, ops, options, callback);
+ }
+
+ // Setup the docs as an array
+ ops = Array.isArray(ops) ? ops : [ops];
+ // Execute write
+ return self.s.wireProtocolHandler.remove(self, self.s.ismaster, ns, self.s.bson, self.s.pool, self.s.callbacks, ops, options, callback);
+}
+
+/**
+ * Authenticate using a specified mechanism
+ * @method
+ * @param {string} mechanism The Auth mechanism we are invoking
+ * @param {string} db The db we are invoking the mechanism against
+ * @param {...object} param Parameters for the specific mechanism
+ * @param {authResultCallback} callback A callback function
+ */
+Server.prototype.auth = function(mechanism, db) {
+ var self = this;
+ var args = Array.prototype.slice.call(arguments, 2);
+ var callback = args.pop();
+
+ // If we don't have the mechanism fail
+ if(self.s.authProviders[mechanism] == null && mechanism != 'default')
+ throw new MongoError(f("auth provider %s does not exist", mechanism));
+
+ // If we have the default mechanism we pick mechanism based on the wire
+ // protocol max version. If it's >= 3 then scram-sha1 otherwise mongodb-cr
+ if(mechanism == 'default' && self.s.ismaster && self.s.ismaster.maxWireVersion >= 3) {
+ mechanism = 'scram-sha-1';
+ } else if(mechanism == 'default') {
+ mechanism = 'mongocr';
+ }
+
+ // Actual arguments
+ var finalArguments = [self, self.s.pool, db].concat(args.slice(0)).concat([function(err, r) {
+ if(err) return callback(err);
+ if(!r) return callback(new MongoError('could not authenticate'));
+ callback(null, new Session({}, self));
+ }]);
+
+ // Let's invoke the auth mechanism
+ self.s.authProviders[mechanism].auth.apply(self.s.authProviders[mechanism], finalArguments);
+}
+
+//
+// Plugin methods
+//
+
+/**
+ * Add custom read preference strategy
+ * @method
+ * @param {string} name Name of the read preference strategy
+ * @param {object} strategy Strategy object instance
+ */
+Server.prototype.addReadPreferenceStrategy = function(name, strategy) {
+ var self = this;
+ if(self.s.readPreferenceStrategies == null) self.s.readPreferenceStrategies = {};
+ self.s.readPreferenceStrategies[name] = strategy;
+}
+
+/**
+ * Add custom authentication mechanism
+ * @method
+ * @param {string} name Name of the authentication mechanism
+ * @param {object} provider Authentication object instance
+ */
+Server.prototype.addAuthProvider = function(name, provider) {
+ var self = this;
+ self.s.authProviders[name] = provider;
+}
+
+/**
+ * Compare two server instances
+ * @method
+ * @param {Server} server Server to compare equality against
+ * @return {boolean}
+ */
+Server.prototype.equals = function(server) {
+ if(typeof server == 'string') return server == this.name;
+ return server.name == this.name;
+}
+
+/**
+ * All raw connections
+ * @method
+ * @return {Connection[]}
+ */
+Server.prototype.connections = function() {
+ return this.s.pool.getAll();
+}
+
+/**
+ * Get server
+ * @method
+ * @param {ReadPreference} [options.readPreference] Specify read preference if command supports it
+ * @return {Server}
+ */
+Server.prototype.getServer = function(options) {
+ return this;
+}
+
+/**
+ * Get connection
+ * @method
+ * @param {ReadPreference} [options.readPreference] Specify read preference if command supports it
+ * @return {Connection}
+ */
+Server.prototype.getConnection = function(options) {
+ return this.s.pool.get();
+}
+
+/**
+ * Get callbacks object
+ * @method
+ * @return {Callbacks}
+ */
+Server.prototype.getCallbacks = function() {
+ return this.s.callbacks;
+}
+
+/**
+ * Name of BSON parser currently used
+ * @method
+ * @return {string}
+ */
+Server.prototype.parserType = function() {
+ var s = this.s;
+ if(s.options.bson.serialize.toString().indexOf('[native code]') != -1)
+ return 'c++';
+ return 'js';
+}
+
+// // Command
+// {
+// find: ns
+// , query: 
+ 
Please support me on [GitTip](https://www.gittip.com/alexgorbatchev/). I've spend days developing and grooming this module and hope to spend more time. If you have bitcoin, please use the QR code or this wallet address [`1CZyBREeHTmy8C5zVGHZHPwqBuWFmEuUCQ`](https://blockchain.info/address/1CZyBREeHTmy8C5zVGHZHPwqBuWFmEuUCQ):
+
+## Installation
+
+ npm install crc
+
+## Running tests
+
+ $ npm install
+ $ npm test
+
+## Usage Example
+
+Calculate a CRC32:
+
+ var crc = require('crc');
+
+ crc.crc32('hello').toString(16);
+ # => "3610a686"
+
+Calculate a CRC32 of a file:
+
+ crc.crc32(fs.readFileSync('README.md', 'utf8')).toString(16);
+ # => "127ad531"
+
+Or using a `Buffer`:
+
+ crc.crc32(fs.readFileSync('README.md')).toString(16);
+ # => "127ad531"
+
+Incrementally calculate a CRC32:
+
+ value = crc32('one');
+ value = crc32('two', value);
+ value = crc32('three', value);
+ value.toString(16);
+ # => "09e1c092"
+
+## Thanks!
+
+[pycrc](http://www.tty1.net/pycrc/) library is which the source of all of the CRC tables.
+
+# License
+
+The MIT License (MIT)
+
+Copyright (c) 2014 Alex Gorbatchev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/server/node_modules/express/node_modules/etag/node_modules/crc/lib/crc.js b/server/node_modules/express/node_modules/etag/node_modules/crc/lib/crc.js
new file mode 100755
index 00000000..1c342b7e
--- /dev/null
+++ b/server/node_modules/express/node_modules/etag/node_modules/crc/lib/crc.js
@@ -0,0 +1,71 @@
+// Generated by CoffeeScript 1.7.1
+var CRC, hex;
+
+hex = require('./hex');
+
+module.exports = CRC = (function() {
+ CRC.prototype.INIT_CRC = 0x00;
+
+ CRC.prototype.XOR_MASK = 0x00;
+
+ CRC.prototype.WIDTH = 0;
+
+ CRC.prototype.pack = function(crc) {
+ return '';
+ };
+
+ CRC.prototype.each_byte = function(buf, cb) {
+ var i, _i, _ref, _results;
+ if (!Buffer.isBuffer(buf)) {
+ buf = Buffer(buf);
+ }
+ _results = [];
+ for (i = _i = 0, _ref = buf.length - 1; 0 <= _ref ? _i <= _ref : _i >= _ref; i = 0 <= _ref ? ++_i : --_i) {
+ _results.push(cb(buf[i]));
+ }
+ return _results;
+ };
+
+ function CRC() {
+ this.crc = this.INIT_CRC;
+ }
+
+ CRC.prototype.digest_length = function() {
+ return Math.ceil(this.WIDTH / 8.0);
+ };
+
+ CRC.prototype.update = function(data) {};
+
+ CRC.prototype.reset = function() {
+ return this.crc = this.INIT_CRC;
+ };
+
+ CRC.prototype.checksum = function(signed) {
+ var sum;
+ if (signed == null) {
+ signed = true;
+ }
+ sum = this.crc ^ this.XOR_MASK;
+ if (signed) {
+ sum = sum >>> 0;
+ }
+ return sum;
+ };
+
+ CRC.prototype.finish = function() {
+ return this.pack(this.checksum());
+ };
+
+ CRC.prototype.hexdigest = function(value) {
+ var result;
+ if (value != null) {
+ this.update(value);
+ }
+ result = this.finish();
+ this.reset();
+ return result;
+ };
+
+ return CRC;
+
+})();
diff --git a/server/node_modules/express/node_modules/etag/node_modules/crc/lib/crc1.js b/server/node_modules/express/node_modules/etag/node_modules/crc/lib/crc1.js
new file mode 100755
index 00000000..f0945678
--- /dev/null
+++ b/server/node_modules/express/node_modules/etag/node_modules/crc/lib/crc1.js
@@ -0,0 +1,21 @@
+// Generated by CoffeeScript 1.7.1
+var Buffer, create;
+
+Buffer = require('buffer').Buffer;
+
+create = require('./create');
+
+module.exports = create('crc1', function(buf, previous) {
+ var accum, byte, crc, _i, _len;
+ if (!Buffer.isBuffer(buf)) {
+ buf = Buffer(buf);
+ }
+ crc = ~~previous;
+ accum = 0;
+ for (_i = 0, _len = buf.length; _i < _len; _i++) {
+ byte = buf[_i];
+ accum += byte;
+ }
+ crc += accum % 256;
+ return crc % 256;
+});
diff --git a/server/node_modules/express/node_modules/etag/node_modules/crc/lib/crc16.js b/server/node_modules/express/node_modules/etag/node_modules/crc/lib/crc16.js
new file mode 100755
index 00000000..a09cd1ef
--- /dev/null
+++ b/server/node_modules/express/node_modules/etag/node_modules/crc/lib/crc16.js
@@ -0,0 +1,25 @@
+// Generated by CoffeeScript 1.7.1
+var Buffer, TABLE, create;
+
+Buffer = require('buffer').Buffer;
+
+create = require('./create');
+
+TABLE = [0x0000, 0xc0c1, 0xc181, 0x0140, 0xc301, 0x03c0, 0x0280, 0xc241, 0xc601, 0x06c0, 0x0780, 0xc741, 0x0500, 0xc5c1, 0xc481, 0x0440, 0xcc01, 0x0cc0, 0x0d80, 0xcd41, 0x0f00, 0xcfc1, 0xce81, 0x0e40, 0x0a00, 0xcac1, 0xcb81, 0x0b40, 0xc901, 0x09c0, 0x0880, 0xc841, 0xd801, 0x18c0, 0x1980, 0xd941, 0x1b00, 0xdbc1, 0xda81, 0x1a40, 0x1e00, 0xdec1, 0xdf81, 0x1f40, 0xdd01, 0x1dc0, 0x1c80, 0xdc41, 0x1400, 0xd4c1, 0xd581, 0x1540, 0xd701, 0x17c0, 0x1680, 0xd641, 0xd201, 0x12c0, 0x1380, 0xd341, 0x1100, 0xd1c1, 0xd081, 0x1040, 0xf001, 0x30c0, 0x3180, 0xf141, 0x3300, 0xf3c1, 0xf281, 0x3240, 0x3600, 0xf6c1, 0xf781, 0x3740, 0xf501, 0x35c0, 0x3480, 0xf441, 0x3c00, 0xfcc1, 0xfd81, 0x3d40, 0xff01, 0x3fc0, 0x3e80, 0xfe41, 0xfa01, 0x3ac0, 0x3b80, 0xfb41, 0x3900, 0xf9c1, 0xf881, 0x3840, 0x2800, 0xe8c1, 0xe981, 0x2940, 0xeb01, 0x2bc0, 0x2a80, 0xea41, 0xee01, 0x2ec0, 0x2f80, 0xef41, 0x2d00, 0xedc1, 0xec81, 0x2c40, 0xe401, 0x24c0, 0x2580, 0xe541, 0x2700, 0xe7c1, 0xe681, 0x2640, 0x2200, 0xe2c1, 0xe381, 0x2340, 0xe101, 0x21c0, 0x2080, 0xe041, 0xa001, 0x60c0, 0x6180, 0xa141, 0x6300, 0xa3c1, 0xa281, 0x6240, 0x6600, 0xa6c1, 0xa781, 0x6740, 0xa501, 0x65c0, 0x6480, 0xa441, 0x6c00, 0xacc1, 0xad81, 0x6d40, 0xaf01, 0x6fc0, 0x6e80, 0xae41, 0xaa01, 0x6ac0, 0x6b80, 0xab41, 0x6900, 0xa9c1, 0xa881, 0x6840, 0x7800, 0xb8c1, 0xb981, 0x7940, 0xbb01, 0x7bc0, 0x7a80, 0xba41, 0xbe01, 0x7ec0, 0x7f80, 0xbf41, 0x7d00, 0xbdc1, 0xbc81, 0x7c40, 0xb401, 0x74c0, 0x7580, 0xb541, 0x7700, 0xb7c1, 0xb681, 0x7640, 0x7200, 0xb2c1, 0xb381, 0x7340, 0xb101, 0x71c0, 0x7080, 0xb041, 0x5000, 0x90c1, 0x9181, 0x5140, 0x9301, 0x53c0, 0x5280, 0x9241, 0x9601, 0x56c0, 0x5780, 0x9741, 0x5500, 0x95c1, 0x9481, 0x5440, 0x9c01, 0x5cc0, 0x5d80, 0x9d41, 0x5f00, 0x9fc1, 0x9e81, 0x5e40, 0x5a00, 0x9ac1, 0x9b81, 0x5b40, 0x9901, 0x59c0, 0x5880, 0x9841, 0x8801, 0x48c0, 0x4980, 0x8941, 0x4b00, 0x8bc1, 0x8a81, 0x4a40, 0x4e00, 0x8ec1, 0x8f81, 0x4f40, 0x8d01, 0x4dc0, 0x4c80, 0x8c41, 0x4400, 0x84c1, 0x8581, 0x4540, 0x8701, 0x47c0, 0x4680, 0x8641, 0x8201, 0x42c0, 0x4380, 0x8341, 0x4100, 0x81c1, 0x8081, 0x4040];
+
+if (typeof Int32Array !== 'undefined') {
+ TABLE = new Int32Array(TABLE);
+}
+
+module.exports = create('crc-16', function(buf, previous) {
+ var byte, crc, _i, _len;
+ if (!Buffer.isBuffer(buf)) {
+ buf = Buffer(buf);
+ }
+ crc = ~~previous;
+ for (_i = 0, _len = buf.length; _i < _len; _i++) {
+ byte = buf[_i];
+ crc = (TABLE[(crc ^ byte) & 0xff] ^ (crc >> 8)) & 0xffff;
+ }
+ return crc;
+});
diff --git a/server/node_modules/express/node_modules/etag/node_modules/crc/lib/crc16_ccitt.js b/server/node_modules/express/node_modules/etag/node_modules/crc/lib/crc16_ccitt.js
new file mode 100755
index 00000000..0bdb0bf6
--- /dev/null
+++ b/server/node_modules/express/node_modules/etag/node_modules/crc/lib/crc16_ccitt.js
@@ -0,0 +1,25 @@
+// Generated by CoffeeScript 1.7.1
+var Buffer, TABLE, create;
+
+Buffer = require('buffer').Buffer;
+
+create = require('./create');
+
+TABLE = [0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7, 0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef, 0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6, 0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de, 0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485, 0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d, 0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4, 0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc, 0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823, 0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b, 0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12, 0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a, 0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41, 0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49, 0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70, 0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78, 0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f, 0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067, 0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e, 0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256, 0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d, 0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405, 0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c, 0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634, 0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab, 0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3, 0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a, 0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92, 0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9, 0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1, 0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8, 0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0];
+
+if (typeof Int32Array !== 'undefined') {
+ TABLE = new Int32Array(TABLE);
+}
+
+module.exports = create('ccitt', function(buf, previous) {
+ var byte, crc, _i, _len;
+ if (!Buffer.isBuffer(buf)) {
+ buf = Buffer(buf);
+ }
+ crc = previous != null ? ~~previous : 0xffff;
+ for (_i = 0, _len = buf.length; _i < _len; _i++) {
+ byte = buf[_i];
+ crc = (TABLE[((crc >> 8) ^ byte) & 0xff] ^ (crc << 8)) & 0xffff;
+ }
+ return crc;
+});
diff --git a/server/node_modules/express/node_modules/etag/node_modules/crc/lib/crc16_modbus.js b/server/node_modules/express/node_modules/etag/node_modules/crc/lib/crc16_modbus.js
new file mode 100755
index 00000000..52a536a0
--- /dev/null
+++ b/server/node_modules/express/node_modules/etag/node_modules/crc/lib/crc16_modbus.js
@@ -0,0 +1,25 @@
+// Generated by CoffeeScript 1.7.1
+var Buffer, TABLE, create;
+
+Buffer = require('buffer').Buffer;
+
+create = require('./create');
+
+TABLE = [0x0000, 0xc0c1, 0xc181, 0x0140, 0xc301, 0x03c0, 0x0280, 0xc241, 0xc601, 0x06c0, 0x0780, 0xc741, 0x0500, 0xc5c1, 0xc481, 0x0440, 0xcc01, 0x0cc0, 0x0d80, 0xcd41, 0x0f00, 0xcfc1, 0xce81, 0x0e40, 0x0a00, 0xcac1, 0xcb81, 0x0b40, 0xc901, 0x09c0, 0x0880, 0xc841, 0xd801, 0x18c0, 0x1980, 0xd941, 0x1b00, 0xdbc1, 0xda81, 0x1a40, 0x1e00, 0xdec1, 0xdf81, 0x1f40, 0xdd01, 0x1dc0, 0x1c80, 0xdc41, 0x1400, 0xd4c1, 0xd581, 0x1540, 0xd701, 0x17c0, 0x1680, 0xd641, 0xd201, 0x12c0, 0x1380, 0xd341, 0x1100, 0xd1c1, 0xd081, 0x1040, 0xf001, 0x30c0, 0x3180, 0xf141, 0x3300, 0xf3c1, 0xf281, 0x3240, 0x3600, 0xf6c1, 0xf781, 0x3740, 0xf501, 0x35c0, 0x3480, 0xf441, 0x3c00, 0xfcc1, 0xfd81, 0x3d40, 0xff01, 0x3fc0, 0x3e80, 0xfe41, 0xfa01, 0x3ac0, 0x3b80, 0xfb41, 0x3900, 0xf9c1, 0xf881, 0x3840, 0x2800, 0xe8c1, 0xe981, 0x2940, 0xeb01, 0x2bc0, 0x2a80, 0xea41, 0xee01, 0x2ec0, 0x2f80, 0xef41, 0x2d00, 0xedc1, 0xec81, 0x2c40, 0xe401, 0x24c0, 0x2580, 0xe541, 0x2700, 0xe7c1, 0xe681, 0x2640, 0x2200, 0xe2c1, 0xe381, 0x2340, 0xe101, 0x21c0, 0x2080, 0xe041, 0xa001, 0x60c0, 0x6180, 0xa141, 0x6300, 0xa3c1, 0xa281, 0x6240, 0x6600, 0xa6c1, 0xa781, 0x6740, 0xa501, 0x65c0, 0x6480, 0xa441, 0x6c00, 0xacc1, 0xad81, 0x6d40, 0xaf01, 0x6fc0, 0x6e80, 0xae41, 0xaa01, 0x6ac0, 0x6b80, 0xab41, 0x6900, 0xa9c1, 0xa881, 0x6840, 0x7800, 0xb8c1, 0xb981, 0x7940, 0xbb01, 0x7bc0, 0x7a80, 0xba41, 0xbe01, 0x7ec0, 0x7f80, 0xbf41, 0x7d00, 0xbdc1, 0xbc81, 0x7c40, 0xb401, 0x74c0, 0x7580, 0xb541, 0x7700, 0xb7c1, 0xb681, 0x7640, 0x7200, 0xb2c1, 0xb381, 0x7340, 0xb101, 0x71c0, 0x7080, 0xb041, 0x5000, 0x90c1, 0x9181, 0x5140, 0x9301, 0x53c0, 0x5280, 0x9241, 0x9601, 0x56c0, 0x5780, 0x9741, 0x5500, 0x95c1, 0x9481, 0x5440, 0x9c01, 0x5cc0, 0x5d80, 0x9d41, 0x5f00, 0x9fc1, 0x9e81, 0x5e40, 0x5a00, 0x9ac1, 0x9b81, 0x5b40, 0x9901, 0x59c0, 0x5880, 0x9841, 0x8801, 0x48c0, 0x4980, 0x8941, 0x4b00, 0x8bc1, 0x8a81, 0x4a40, 0x4e00, 0x8ec1, 0x8f81, 0x4f40, 0x8d01, 0x4dc0, 0x4c80, 0x8c41, 0x4400, 0x84c1, 0x8581, 0x4540, 0x8701, 0x47c0, 0x4680, 0x8641, 0x8201, 0x42c0, 0x4380, 0x8341, 0x4100, 0x81c1, 0x8081, 0x4040];
+
+if (typeof Int32Array !== 'undefined') {
+ TABLE = new Int32Array(TABLE);
+}
+
+module.exports = create('crc-16-modbus', function(buf, previous) {
+ var byte, crc, _i, _len;
+ if (!Buffer.isBuffer(buf)) {
+ buf = Buffer(buf);
+ }
+ crc = previous != null ? ~~previous : 0xffff;
+ for (_i = 0, _len = buf.length; _i < _len; _i++) {
+ byte = buf[_i];
+ crc = (TABLE[(crc ^ byte) & 0xff] ^ (crc >> 8)) & 0xffff;
+ }
+ return crc;
+});
diff --git a/server/node_modules/express/node_modules/etag/node_modules/crc/lib/crc24.js b/server/node_modules/express/node_modules/etag/node_modules/crc/lib/crc24.js
new file mode 100755
index 00000000..ff67bc1e
--- /dev/null
+++ b/server/node_modules/express/node_modules/etag/node_modules/crc/lib/crc24.js
@@ -0,0 +1,25 @@
+// Generated by CoffeeScript 1.7.1
+var Buffer, TABLE, create;
+
+Buffer = require('buffer').Buffer;
+
+create = require('./create');
+
+TABLE = [0x000000, 0x864cfb, 0x8ad50d, 0x0c99f6, 0x93e6e1, 0x15aa1a, 0x1933ec, 0x9f7f17, 0xa18139, 0x27cdc2, 0x2b5434, 0xad18cf, 0x3267d8, 0xb42b23, 0xb8b2d5, 0x3efe2e, 0xc54e89, 0x430272, 0x4f9b84, 0xc9d77f, 0x56a868, 0xd0e493, 0xdc7d65, 0x5a319e, 0x64cfb0, 0xe2834b, 0xee1abd, 0x685646, 0xf72951, 0x7165aa, 0x7dfc5c, 0xfbb0a7, 0x0cd1e9, 0x8a9d12, 0x8604e4, 0x00481f, 0x9f3708, 0x197bf3, 0x15e205, 0x93aefe, 0xad50d0, 0x2b1c2b, 0x2785dd, 0xa1c926, 0x3eb631, 0xb8faca, 0xb4633c, 0x322fc7, 0xc99f60, 0x4fd39b, 0x434a6d, 0xc50696, 0x5a7981, 0xdc357a, 0xd0ac8c, 0x56e077, 0x681e59, 0xee52a2, 0xe2cb54, 0x6487af, 0xfbf8b8, 0x7db443, 0x712db5, 0xf7614e, 0x19a3d2, 0x9fef29, 0x9376df, 0x153a24, 0x8a4533, 0x0c09c8, 0x00903e, 0x86dcc5, 0xb822eb, 0x3e6e10, 0x32f7e6, 0xb4bb1d, 0x2bc40a, 0xad88f1, 0xa11107, 0x275dfc, 0xdced5b, 0x5aa1a0, 0x563856, 0xd074ad, 0x4f0bba, 0xc94741, 0xc5deb7, 0x43924c, 0x7d6c62, 0xfb2099, 0xf7b96f, 0x71f594, 0xee8a83, 0x68c678, 0x645f8e, 0xe21375, 0x15723b, 0x933ec0, 0x9fa736, 0x19ebcd, 0x8694da, 0x00d821, 0x0c41d7, 0x8a0d2c, 0xb4f302, 0x32bff9, 0x3e260f, 0xb86af4, 0x2715e3, 0xa15918, 0xadc0ee, 0x2b8c15, 0xd03cb2, 0x567049, 0x5ae9bf, 0xdca544, 0x43da53, 0xc596a8, 0xc90f5e, 0x4f43a5, 0x71bd8b, 0xf7f170, 0xfb6886, 0x7d247d, 0xe25b6a, 0x641791, 0x688e67, 0xeec29c, 0x3347a4, 0xb50b5f, 0xb992a9, 0x3fde52, 0xa0a145, 0x26edbe, 0x2a7448, 0xac38b3, 0x92c69d, 0x148a66, 0x181390, 0x9e5f6b, 0x01207c, 0x876c87, 0x8bf571, 0x0db98a, 0xf6092d, 0x7045d6, 0x7cdc20, 0xfa90db, 0x65efcc, 0xe3a337, 0xef3ac1, 0x69763a, 0x578814, 0xd1c4ef, 0xdd5d19, 0x5b11e2, 0xc46ef5, 0x42220e, 0x4ebbf8, 0xc8f703, 0x3f964d, 0xb9dab6, 0xb54340, 0x330fbb, 0xac70ac, 0x2a3c57, 0x26a5a1, 0xa0e95a, 0x9e1774, 0x185b8f, 0x14c279, 0x928e82, 0x0df195, 0x8bbd6e, 0x872498, 0x016863, 0xfad8c4, 0x7c943f, 0x700dc9, 0xf64132, 0x693e25, 0xef72de, 0xe3eb28, 0x65a7d3, 0x5b59fd, 0xdd1506, 0xd18cf0, 0x57c00b, 0xc8bf1c, 0x4ef3e7, 0x426a11, 0xc426ea, 0x2ae476, 0xaca88d, 0xa0317b, 0x267d80, 0xb90297, 0x3f4e6c, 0x33d79a, 0xb59b61, 0x8b654f, 0x0d29b4, 0x01b042, 0x87fcb9, 0x1883ae, 0x9ecf55, 0x9256a3, 0x141a58, 0xefaaff, 0x69e604, 0x657ff2, 0xe33309, 0x7c4c1e, 0xfa00e5, 0xf69913, 0x70d5e8, 0x4e2bc6, 0xc8673d, 0xc4fecb, 0x42b230, 0xddcd27, 0x5b81dc, 0x57182a, 0xd154d1, 0x26359f, 0xa07964, 0xace092, 0x2aac69, 0xb5d37e, 0x339f85, 0x3f0673, 0xb94a88, 0x87b4a6, 0x01f85d, 0x0d61ab, 0x8b2d50, 0x145247, 0x921ebc, 0x9e874a, 0x18cbb1, 0xe37b16, 0x6537ed, 0x69ae1b, 0xefe2e0, 0x709df7, 0xf6d10c, 0xfa48fa, 0x7c0401, 0x42fa2f, 0xc4b6d4, 0xc82f22, 0x4e63d9, 0xd11cce, 0x575035, 0x5bc9c3, 0xdd8538];
+
+if (typeof Int32Array !== 'undefined') {
+ TABLE = new Int32Array(TABLE);
+}
+
+module.exports = create('crc-24', function(buf, previous) {
+ var byte, crc, _i, _len;
+ if (!Buffer.isBuffer(buf)) {
+ buf = Buffer(buf);
+ }
+ crc = previous != null ? ~~previous : 0xb704ce;
+ for (_i = 0, _len = buf.length; _i < _len; _i++) {
+ byte = buf[_i];
+ crc = (TABLE[((crc >> 16) ^ byte) & 0xff] ^ (crc << 8)) & 0xffffff;
+ }
+ return crc;
+});
diff --git a/server/node_modules/express/node_modules/etag/node_modules/crc/lib/crc32.js b/server/node_modules/express/node_modules/etag/node_modules/crc/lib/crc32.js
new file mode 100755
index 00000000..20bc0247
--- /dev/null
+++ b/server/node_modules/express/node_modules/etag/node_modules/crc/lib/crc32.js
@@ -0,0 +1,25 @@
+// Generated by CoffeeScript 1.7.1
+var Buffer, TABLE, create;
+
+Buffer = require('buffer').Buffer;
+
+create = require('./create');
+
+TABLE = [0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d];
+
+if (typeof Int32Array !== 'undefined') {
+ TABLE = new Int32Array(TABLE);
+}
+
+module.exports = create('crc-32', function(buf, previous) {
+ var byte, crc, _i, _len;
+ if (!Buffer.isBuffer(buf)) {
+ buf = Buffer(buf);
+ }
+ crc = previous === 0 ? 0 : ~~previous ^ -1;
+ for (_i = 0, _len = buf.length; _i < _len; _i++) {
+ byte = buf[_i];
+ crc = TABLE[(crc ^ byte) & 0xff] ^ (crc >>> 8);
+ }
+ return crc ^ -1;
+});
diff --git a/server/node_modules/express/node_modules/etag/node_modules/crc/lib/crc8.js b/server/node_modules/express/node_modules/etag/node_modules/crc/lib/crc8.js
new file mode 100755
index 00000000..6ebe77c2
--- /dev/null
+++ b/server/node_modules/express/node_modules/etag/node_modules/crc/lib/crc8.js
@@ -0,0 +1,25 @@
+// Generated by CoffeeScript 1.7.1
+var Buffer, TABLE, create;
+
+Buffer = require('buffer').Buffer;
+
+create = require('./create');
+
+TABLE = [0x00, 0x07, 0x0e, 0x09, 0x1c, 0x1b, 0x12, 0x15, 0x38, 0x3f, 0x36, 0x31, 0x24, 0x23, 0x2a, 0x2d, 0x70, 0x77, 0x7e, 0x79, 0x6c, 0x6b, 0x62, 0x65, 0x48, 0x4f, 0x46, 0x41, 0x54, 0x53, 0x5a, 0x5d, 0xe0, 0xe7, 0xee, 0xe9, 0xfc, 0xfb, 0xf2, 0xf5, 0xd8, 0xdf, 0xd6, 0xd1, 0xc4, 0xc3, 0xca, 0xcd, 0x90, 0x97, 0x9e, 0x99, 0x8c, 0x8b, 0x82, 0x85, 0xa8, 0xaf, 0xa6, 0xa1, 0xb4, 0xb3, 0xba, 0xbd, 0xc7, 0xc0, 0xc9, 0xce, 0xdb, 0xdc, 0xd5, 0xd2, 0xff, 0xf8, 0xf1, 0xf6, 0xe3, 0xe4, 0xed, 0xea, 0xb7, 0xb0, 0xb9, 0xbe, 0xab, 0xac, 0xa5, 0xa2, 0x8f, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9d, 0x9a, 0x27, 0x20, 0x29, 0x2e, 0x3b, 0x3c, 0x35, 0x32, 0x1f, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0d, 0x0a, 0x57, 0x50, 0x59, 0x5e, 0x4b, 0x4c, 0x45, 0x42, 0x6f, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7d, 0x7a, 0x89, 0x8e, 0x87, 0x80, 0x95, 0x92, 0x9b, 0x9c, 0xb1, 0xb6, 0xbf, 0xb8, 0xad, 0xaa, 0xa3, 0xa4, 0xf9, 0xfe, 0xf7, 0xf0, 0xe5, 0xe2, 0xeb, 0xec, 0xc1, 0xc6, 0xcf, 0xc8, 0xdd, 0xda, 0xd3, 0xd4, 0x69, 0x6e, 0x67, 0x60, 0x75, 0x72, 0x7b, 0x7c, 0x51, 0x56, 0x5f, 0x58, 0x4d, 0x4a, 0x43, 0x44, 0x19, 0x1e, 0x17, 0x10, 0x05, 0x02, 0x0b, 0x0c, 0x21, 0x26, 0x2f, 0x28, 0x3d, 0x3a, 0x33, 0x34, 0x4e, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5c, 0x5b, 0x76, 0x71, 0x78, 0x7f, 0x6a, 0x6d, 0x64, 0x63, 0x3e, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2c, 0x2b, 0x06, 0x01, 0x08, 0x0f, 0x1a, 0x1d, 0x14, 0x13, 0xae, 0xa9, 0xa0, 0xa7, 0xb2, 0xb5, 0xbc, 0xbb, 0x96, 0x91, 0x98, 0x9f, 0x8a, 0x8d, 0x84, 0x83, 0xde, 0xd9, 0xd0, 0xd7, 0xc2, 0xc5, 0xcc, 0xcb, 0xe6, 0xe1, 0xe8, 0xef, 0xfa, 0xfd, 0xf4, 0xf3];
+
+if (typeof Int32Array !== 'undefined') {
+ TABLE = new Int32Array(TABLE);
+}
+
+module.exports = create('crc-8', function(buf, previous) {
+ var byte, crc, _i, _len;
+ if (!Buffer.isBuffer(buf)) {
+ buf = Buffer(buf);
+ }
+ crc = ~~previous;
+ for (_i = 0, _len = buf.length; _i < _len; _i++) {
+ byte = buf[_i];
+ crc = TABLE[(crc ^ byte) & 0xff] & 0xff;
+ }
+ return crc;
+});
diff --git a/server/node_modules/express/node_modules/etag/node_modules/crc/lib/crc8_1wire.js b/server/node_modules/express/node_modules/etag/node_modules/crc/lib/crc8_1wire.js
new file mode 100755
index 00000000..b5612463
--- /dev/null
+++ b/server/node_modules/express/node_modules/etag/node_modules/crc/lib/crc8_1wire.js
@@ -0,0 +1,25 @@
+// Generated by CoffeeScript 1.7.1
+var Buffer, TABLE, create;
+
+Buffer = require('buffer').Buffer;
+
+create = require('./create');
+
+TABLE = [0x00, 0x5e, 0xbc, 0xe2, 0x61, 0x3f, 0xdd, 0x83, 0xc2, 0x9c, 0x7e, 0x20, 0xa3, 0xfd, 0x1f, 0x41, 0x9d, 0xc3, 0x21, 0x7f, 0xfc, 0xa2, 0x40, 0x1e, 0x5f, 0x01, 0xe3, 0xbd, 0x3e, 0x60, 0x82, 0xdc, 0x23, 0x7d, 0x9f, 0xc1, 0x42, 0x1c, 0xfe, 0xa0, 0xe1, 0xbf, 0x5d, 0x03, 0x80, 0xde, 0x3c, 0x62, 0xbe, 0xe0, 0x02, 0x5c, 0xdf, 0x81, 0x63, 0x3d, 0x7c, 0x22, 0xc0, 0x9e, 0x1d, 0x43, 0xa1, 0xff, 0x46, 0x18, 0xfa, 0xa4, 0x27, 0x79, 0x9b, 0xc5, 0x84, 0xda, 0x38, 0x66, 0xe5, 0xbb, 0x59, 0x07, 0xdb, 0x85, 0x67, 0x39, 0xba, 0xe4, 0x06, 0x58, 0x19, 0x47, 0xa5, 0xfb, 0x78, 0x26, 0xc4, 0x9a, 0x65, 0x3b, 0xd9, 0x87, 0x04, 0x5a, 0xb8, 0xe6, 0xa7, 0xf9, 0x1b, 0x45, 0xc6, 0x98, 0x7a, 0x24, 0xf8, 0xa6, 0x44, 0x1a, 0x99, 0xc7, 0x25, 0x7b, 0x3a, 0x64, 0x86, 0xd8, 0x5b, 0x05, 0xe7, 0xb9, 0x8c, 0xd2, 0x30, 0x6e, 0xed, 0xb3, 0x51, 0x0f, 0x4e, 0x10, 0xf2, 0xac, 0x2f, 0x71, 0x93, 0xcd, 0x11, 0x4f, 0xad, 0xf3, 0x70, 0x2e, 0xcc, 0x92, 0xd3, 0x8d, 0x6f, 0x31, 0xb2, 0xec, 0x0e, 0x50, 0xaf, 0xf1, 0x13, 0x4d, 0xce, 0x90, 0x72, 0x2c, 0x6d, 0x33, 0xd1, 0x8f, 0x0c, 0x52, 0xb0, 0xee, 0x32, 0x6c, 0x8e, 0xd0, 0x53, 0x0d, 0xef, 0xb1, 0xf0, 0xae, 0x4c, 0x12, 0x91, 0xcf, 0x2d, 0x73, 0xca, 0x94, 0x76, 0x28, 0xab, 0xf5, 0x17, 0x49, 0x08, 0x56, 0xb4, 0xea, 0x69, 0x37, 0xd5, 0x8b, 0x57, 0x09, 0xeb, 0xb5, 0x36, 0x68, 0x8a, 0xd4, 0x95, 0xcb, 0x29, 0x77, 0xf4, 0xaa, 0x48, 0x16, 0xe9, 0xb7, 0x55, 0x0b, 0x88, 0xd6, 0x34, 0x6a, 0x2b, 0x75, 0x97, 0xc9, 0x4a, 0x14, 0xf6, 0xa8, 0x74, 0x2a, 0xc8, 0x96, 0x15, 0x4b, 0xa9, 0xf7, 0xb6, 0xe8, 0x0a, 0x54, 0xd7, 0x89, 0x6b, 0x35];
+
+if (typeof Int32Array !== 'undefined') {
+ TABLE = new Int32Array(TABLE);
+}
+
+module.exports = create('dallas-1-wire', function(buf, previous) {
+ var byte, crc, _i, _len;
+ if (!Buffer.isBuffer(buf)) {
+ buf = Buffer(buf);
+ }
+ crc = ~~previous;
+ for (_i = 0, _len = buf.length; _i < _len; _i++) {
+ byte = buf[_i];
+ crc = TABLE[(crc ^ byte) & 0xff] & 0xff;
+ }
+ return crc;
+});
diff --git a/server/node_modules/express/node_modules/etag/node_modules/crc/lib/create.js b/server/node_modules/express/node_modules/etag/node_modules/crc/lib/create.js
new file mode 100755
index 00000000..2d856bd2
--- /dev/null
+++ b/server/node_modules/express/node_modules/etag/node_modules/crc/lib/create.js
@@ -0,0 +1,11 @@
+// Generated by CoffeeScript 1.7.1
+module.exports = function(model, calc) {
+ var fn;
+ fn = function(buf, previous) {
+ return calc(buf, previous) >>> 0;
+ };
+ fn.signed = calc;
+ fn.unsigned = fn;
+ fn.model = model;
+ return fn;
+};
diff --git a/server/node_modules/express/node_modules/etag/node_modules/crc/lib/hex.js b/server/node_modules/express/node_modules/etag/node_modules/crc/lib/hex.js
new file mode 100755
index 00000000..0a6aa4c5
--- /dev/null
+++ b/server/node_modules/express/node_modules/etag/node_modules/crc/lib/hex.js
@@ -0,0 +1,9 @@
+// Generated by CoffeeScript 1.7.1
+module.exports = function(number) {
+ var result;
+ result = number.toString(16);
+ while (result.length % 2) {
+ result = "0" + result;
+ }
+ return result;
+};
diff --git a/server/node_modules/express/node_modules/etag/node_modules/crc/lib/index.js b/server/node_modules/express/node_modules/etag/node_modules/crc/lib/index.js
new file mode 100755
index 00000000..15ac34cd
--- /dev/null
+++ b/server/node_modules/express/node_modules/etag/node_modules/crc/lib/index.js
@@ -0,0 +1,11 @@
+// Generated by CoffeeScript 1.7.1
+module.exports = {
+ crc1: require('./crc1'),
+ crc8: require('./crc8'),
+ crc81wire: require('./crc8_1wire'),
+ crc16: require('./crc16'),
+ crc16ccitt: require('./crc16_ccitt'),
+ crc16modbus: require('./crc16_modbus'),
+ crc24: require('./crc24'),
+ crc32: require('./crc32')
+};
diff --git a/server/node_modules/express/node_modules/etag/node_modules/crc/package.json b/server/node_modules/express/node_modules/etag/node_modules/crc/package.json
new file mode 100755
index 00000000..1b2418aa
--- /dev/null
+++ b/server/node_modules/express/node_modules/etag/node_modules/crc/package.json
@@ -0,0 +1,57 @@
+{
+ "name": "crc",
+ "version": "3.2.1",
+ "description": "Various CRC JavaScript implementations",
+ "keywords": [
+ "crc"
+ ],
+ "main": "./lib/index.js",
+ "scripts": {
+ "test": "mocha test/*.spec.coffee",
+ "pretest": "coffee --bare --output ./lib --compile ./src/*.coffee"
+ },
+ "author": {
+ "name": "Alex Gorbatchev",
+ "url": "https://github.com/alexgorbatchev"
+ },
+ "devDependencies": {
+ "beautify-benchmark": "^0.2.4",
+ "benchmark": "^1.0.0",
+ "buffer-crc32": "^0.2.3",
+ "chai": "~1.9.1",
+ "coffee-errors": "~0.8.6",
+ "coffee-script": "~1.7.1",
+ "mocha": "*",
+ "seedrandom": "^2.3.6"
+ },
+ "homepage": "https://github.com/alexgorbatchev/node-crc",
+ "bugs": {
+ "url": "https://github.com/alexgorbatchev/node-crc/issues"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/alexgorbatchev/node-crc.git"
+ },
+ "license": "MIT",
+ "gitHead": "71caf362b061992bfe4ca8706ee264e764d2e88e",
+ "_id": "crc@3.2.1",
+ "_shasum": "5d9c8fb77a245cd5eca291e5d2d005334bab0082",
+ "_from": "crc@3.2.1",
+ "_npmVersion": "1.4.13",
+ "_npmUser": {
+ "name": "alexgorbatchev",
+ "email": "alex.gorbatchev@gmail.com"
+ },
+ "maintainers": [
+ {
+ "name": "alexgorbatchev",
+ "email": "alex.gorbatchev@gmail.com"
+ }
+ ],
+ "dist": {
+ "shasum": "5d9c8fb77a245cd5eca291e5d2d005334bab0082",
+ "tarball": "http://registry.npmjs.org/crc/-/crc-3.2.1.tgz"
+ },
+ "directories": {},
+ "_resolved": "https://registry.npmjs.org/crc/-/crc-3.2.1.tgz"
+}
diff --git a/server/node_modules/express/node_modules/etag/package.json b/server/node_modules/express/node_modules/etag/package.json
new file mode 100755
index 00000000..13f0b417
--- /dev/null
+++ b/server/node_modules/express/node_modules/etag/package.json
@@ -0,0 +1,74 @@
+{
+ "name": "etag",
+ "description": "Create simple ETags",
+ "version": "1.5.1",
+ "contributors": [
+ {
+ "name": "Douglas Christopher Wilson",
+ "email": "doug@somethingdoug.com"
+ },
+ {
+ "name": "David Björklund",
+ "email": "david.bjorklund@gmail.com"
+ }
+ ],
+ "license": "MIT",
+ "keywords": [
+ "etag",
+ "http",
+ "res"
+ ],
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/jshttp/etag"
+ },
+ "dependencies": {
+ "crc": "3.2.1"
+ },
+ "devDependencies": {
+ "benchmark": "1.0.0",
+ "beautify-benchmark": "0.2.4",
+ "istanbul": "0.3.2",
+ "mocha": "~1.21.4",
+ "seedrandom": "~2.3.6"
+ },
+ "files": [
+ "LICENSE",
+ "HISTORY.md",
+ "index.js"
+ ],
+ "engines": {
+ "node": ">= 0.6"
+ },
+ "scripts": {
+ "bench": "node benchmark/index.js",
+ "test": "mocha --reporter spec --bail --check-leaks test/",
+ "test-cov": "istanbul cover node_modules/mocha/bin/_mocha -- --reporter dot --check-leaks test/",
+ "test-travis": "istanbul cover node_modules/mocha/bin/_mocha --report lcovonly -- --reporter spec --check-leaks test/"
+ },
+ "gitHead": "27335e2265388109e50a9f037452081dc8a8260f",
+ "bugs": {
+ "url": "https://github.com/jshttp/etag/issues"
+ },
+ "homepage": "https://github.com/jshttp/etag",
+ "_id": "etag@1.5.1",
+ "_shasum": "54c50de04ee42695562925ac566588291be7e9ea",
+ "_from": "etag@~1.5.0",
+ "_npmVersion": "1.4.21",
+ "_npmUser": {
+ "name": "dougwilson",
+ "email": "doug@somethingdoug.com"
+ },
+ "maintainers": [
+ {
+ "name": "dougwilson",
+ "email": "doug@somethingdoug.com"
+ }
+ ],
+ "dist": {
+ "shasum": "54c50de04ee42695562925ac566588291be7e9ea",
+ "tarball": "http://registry.npmjs.org/etag/-/etag-1.5.1.tgz"
+ },
+ "directories": {},
+ "_resolved": "https://registry.npmjs.org/etag/-/etag-1.5.1.tgz"
+}
diff --git a/server/node_modules/express/node_modules/finalhandler/HISTORY.md b/server/node_modules/express/node_modules/finalhandler/HISTORY.md
new file mode 100755
index 00000000..2c7e1ef9
--- /dev/null
+++ b/server/node_modules/express/node_modules/finalhandler/HISTORY.md
@@ -0,0 +1,51 @@
+0.3.2 / 2014-10-22
+==================
+
+ * deps: on-finished@~2.1.1
+ - Fix handling of pipelined requests
+
+0.3.1 / 2014-10-16
+==================
+
+ * deps: debug@~2.1.0
+ - Implement `DEBUG_FD` env variable support
+
+0.3.0 / 2014-09-17
+==================
+
+ * Terminate in progress response only on error
+ * Use `on-finished` to determine request status
+
+0.2.0 / 2014-09-03
+==================
+
+ * Set `X-Content-Type-Options: nosniff` header
+ * deps: debug@~2.0.0
+
+0.1.0 / 2014-07-16
+==================
+
+ * Respond after request fully read
+ - prevents hung responses and socket hang ups
+ * deps: debug@1.0.4
+
+0.0.3 / 2014-07-11
+==================
+
+ * deps: debug@1.0.3
+ - Add support for multiple wildcards in namespaces
+
+0.0.2 / 2014-06-19
+==================
+
+ * Handle invalid status codes
+
+0.0.1 / 2014-06-05
+==================
+
+ * deps: debug@1.0.2
+
+0.0.0 / 2014-06-05
+==================
+
+ * Extracted from connect/express
diff --git a/server/node_modules/express/node_modules/finalhandler/LICENSE b/server/node_modules/express/node_modules/finalhandler/LICENSE
new file mode 100755
index 00000000..eda23054
--- /dev/null
+++ b/server/node_modules/express/node_modules/finalhandler/LICENSE
@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2014 Douglas Christopher Wilson 
+