mongodb 2.1.0-alpha → 2.1.2

package/lib/mongo_client.js

@@ -4,12 +4,13 @@ var parse = require('./url_parser')
   , Server = require('./server')
   , Mongos = require('./mongos')
   , ReplSet = require('./replset')
+  , Define = require('./metadata')
   , 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');
@@ -51,12 +52,14 @@ function MongoClient() {
    * @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 {object} [options.promiseLibrary=null] A Promise library class the application wishes to use such as Bluebird, must be ES6 compatible
-   * @param {MongoClient~connectCallback} callback The command result callback
+   * @param {MongoClient~connectCallback} [callback] The command result callback
    * @return {Promise} returns Promise if no callback passed
-   */  
+   */
   this.connect = MongoClient.connect;
 }
 
+var define = MongoClient.define = new Define('MongoClient', MongoClient, false);
+
 /**
  * Connect to MongoDB using a url as documented at
  *
@@ -74,9 +77,9 @@ function MongoClient() {
  * @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 {object} [options.promiseLibrary=null] A Promise library class the application wishes to use such as Bluebird, must be ES6 compatible
- * @param {MongoClient~connectCallback} callback The command result callback
+ * @param {MongoClient~connectCallback} [callback] The command result callback
  * @return {Promise} returns Promise if no callback passed
- */  
+ */
 MongoClient.connect = function(url, options, callback) {
   var args = Array.prototype.slice.call(arguments, 1);
   callback = typeof args[args.length - 1] == 'function' ? args.pop() : null;
@@ -106,15 +109,16 @@ MongoClient.connect = function(url, options, callback) {
   connect(url, options, callback);
 }
 
+define.staticMethod('connect', {callback: true, promise:true});
+
 var connect = function(url, options, callback) {
-  // 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) 
+  if(callback == null)
     throw new Error("no callback function provided");
 
   // Parse the string
@@ -135,17 +139,19 @@ var connect = function(url, options, callback) {
 
   // Merge in any replicaset server options
   if(replSetServersOptions) {
-    for(var name in replSetServersOptions) object.rs_options[name] = replSetServersOptions[name];    
+    for(var name in replSetServersOptions) object.rs_options[name] = replSetServersOptions[name];
   }
 
-  if(replSetServersOptions.ssl 
+  if(replSetServersOptions.ssl
     || replSetServersOptions.sslValidate
+    || replSetServersOptions.checkServerIdentity
     || replSetServersOptions.sslCA
     || replSetServersOptions.sslCert
     || replSetServersOptions.sslKey
     || replSetServersOptions.sslPass) {
     object.server_options.ssl = replSetServersOptions.ssl;
     object.server_options.sslValidate = replSetServersOptions.sslValidate;
+    object.server_options.checkServerIdentity = replSetServersOptions.checkServerIdentity;
     object.server_options.sslCA = replSetServersOptions.sslCA;
     object.server_options.sslCert = replSetServersOptions.sslCert;
     object.server_options.sslKey = replSetServersOptions.sslKey;
@@ -154,7 +160,7 @@ var connect = function(url, options, callback) {
 
   // Merge in any replicaset server options
   if(mongosOptions) {
-    for(var name in mongosOptions) object.mongos_options[name] = mongosOptions[name];    
+    for(var name in mongosOptions) object.mongos_options[name] = mongosOptions[name];
   }
 
   if(typeof object.server_options.poolSize == 'number') {
@@ -162,14 +168,16 @@ var connect = function(url, options, callback) {
     if(!object.rs_options.poolSize) object.rs_options.poolSize = object.server_options.poolSize;
   }
 
-  if(mongosOptions.ssl 
+  if(mongosOptions.ssl
     || mongosOptions.sslValidate
+    || mongosOptions.checkServerIdentity
     || mongosOptions.sslCA
     || mongosOptions.sslCert
     || mongosOptions.sslKey
     || mongosOptions.sslPass) {
     object.server_options.ssl = mongosOptions.ssl;
     object.server_options.sslValidate = mongosOptions.sslValidate;
+    object.server_options.checkServerIdentity = mongosOptions.checkServerIdentity;
     object.server_options.sslCA = mongosOptions.sslCA;
     object.server_options.sslCert = mongosOptions.sslCert;
     object.server_options.sslKey = mongosOptions.sslKey;
@@ -207,8 +215,8 @@ var connect = function(url, options, callback) {
     var _server_options = {
         poolSize:1
       , socketOptions: {
-          connectTimeoutMS: providedSocketOptions.connectTimeoutMS || 30000
-        , socketTimeoutMS:  providedSocketOptions.socketTimeoutMS || 30000
+          connectTimeoutMS: providedSocketOptions.connectTimeoutMS || (1000 * 120)
+        , socketTimeoutMS:  providedSocketOptions.socketTimeoutMS || (1000 * 120)
       }
       , auto_reconnect:false};
 
@@ -216,6 +224,7 @@ var connect = function(url, options, callback) {
     if(object.server_options.ssl) {
       _server_options.ssl = object.server_options.ssl;
       _server_options.sslValidate = object.server_options.sslValidate;
+      _server_options.checkServerIdentity = object.server_options.checkServerIdentity;
       _server_options.sslCA = object.server_options.sslCA;
       _server_options.sslCert = object.server_options.sslCert;
       _server_options.sslKey = object.server_options.sslKey;
@@ -223,6 +232,7 @@ var connect = function(url, options, callback) {
     } else if(object.rs_options.ssl) {
       _server_options.ssl = object.rs_options.ssl;
       _server_options.sslValidate = object.rs_options.sslValidate;
+      _server_options.checkServerIdentity = object.rs_options.checkServerIdentity;
       _server_options.sslCA = object.rs_options.sslCA;
       _server_options.sslCert = object.rs_options.sslCert;
       _server_options.sslKey = object.rs_options.sslKey;
@@ -232,27 +242,28 @@ var connect = function(url, options, callback) {
     // Error
     var error = null;
     // Set up the Server object
-    var _server = object.servers[i].domain_socket 
+    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) { 
+    var connectFunction = function(__server) {
       // Attempt connect
-      new Db(object.dbName, __server, {w:1, native_parser:false}).open(function(err, db) {
+      new Db(object.dbName, __server, {w:1, native_parser:false, promiseLibrary:options.promiseLibrary}).open(function(err, db) {
         // Update number of servers
-        totalNumberOfServers = totalNumberOfServers - 1;          
+        totalNumberOfServers = totalNumberOfServers - 1;
+
         // If no error do the correct checks
         if(!err) {
           // Close the connection
           db.close();
+          // Get the last ismaster document
           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;
@@ -273,39 +284,58 @@ var connect = function(url, options, callback) {
                 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) {
+
+          if(totalNumberOfMongodServers == 0
+            && totalNumberOfMongosServers == 0
+            && object.servers.length == 1
+            && (!object.rs_options.replicaSet || !object.rs_options.rs_name)) {
+
             var obj = object.servers[0];
-            serverConfig = obj.domain_socket ? 
+            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) {
+              : new Server(obj.host, obj.port, object.server_options);
+
+          } else if(totalNumberOfMongodServers > 0
+            || totalNumberOfMongosServers > 0
+            || object.rs_options.replicaSet || object.rs_options.rs_name) {
+
             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);
+                return serverObj.domain_socket ?
+                  new Server(serverObj.domain_socket, 27017, object.server_options)
+                : 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;
+
+                // If no replicaset name was provided, we wish to perform a
+                // direct connection
+                if(totalNumberOfMongodServers == 1
+                  && (!object.rs_options.replicaSet && !object.rs_options.rs_name)) {
+                  serverConfig = finalServers[0];
+                } else if(totalNumberOfMongodServers == 1) {
+                  object.rs_options.replicaSet = object.rs_options.replicaSet || object.rs_options.rs_name;
+                  serverConfig = new ReplSet(finalServers, object.rs_options);
+                } else {
+                  serverConfig = new ReplSet(finalServers, object.rs_options);
                 }
-                serverConfig = new ReplSet(finalServers, object.rs_options);
+
               } catch(err) {
                 return callback(err, null);
               }
             } else {
-              serverConfig = new Mongos(finalServers, object.mongos_options);                         
+              serverConfig = new Mongos(finalServers, object.mongos_options);
             }
           }
 
@@ -325,12 +355,12 @@ var connect = function(url, options, callback) {
           // Set up all options etc and connect to the database
           _finishConnecting(serverConfig, object, options, callback)
         }
-      });        
+      });
     }
 
     // Wrap the context of the call
-    connectFunction(_server);    
-  }      
+    connectFunction(_server);
+  }
 }
 
 var _setNativeParser = function(db_options) {
@@ -374,7 +404,7 @@ var _finishConnecting = function(serverConfig, object, options, callback) {
   // Set up the db options
   var db = new Db(object.dbName, serverConfig, object.db_options);
   // Open the db
-  db.open(function(err, db){    
+  db.open(function(err, db){
 
     if(err) {
       return process.nextTick(function() {
@@ -408,7 +438,7 @@ var _finishConnecting = function(serverConfig, object, options, callback) {
         if(success){
           process.nextTick(function() {
             try {
-              callback(null, db);            
+              callback(null, db);
             } catch (err) {
               if(db) db.close();
               throw err
@@ -429,7 +459,7 @@ var _finishConnecting = function(serverConfig, object, options, callback) {
     } else {
       process.nextTick(function() {
         try {
-          callback(err, db);            
+          callback(err, db);
         } catch (err) {
           if(db) db.close();
           throw err

package/lib/mongos.js

@@ -5,8 +5,12 @@ var EventEmitter = require('events').EventEmitter
   , f = require('util').format
   , ServerCapabilities = require('./topology_base').ServerCapabilities
   , MongoCR = require('mongodb-core').MongoCR
+  , MongoError = require('mongodb-core').MongoError
   , CMongos = require('mongodb-core').Mongos
   , Cursor = require('./cursor')
+  , AggregationCursor = require('./aggregation_cursor')
+  , CommandCursor = require('./command_cursor')
+  , Define = require('./metadata')
   , Server = require('./server')
   , Store = require('./topology_base').Store
   , shallowClone = require('./utils').shallowClone;
@@ -14,7 +18,7 @@ var EventEmitter = require('events').EventEmitter
 /**
  * @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,
@@ -39,17 +43,18 @@ var EventEmitter = require('events').EventEmitter
  * @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 {boolean} [options.ssl=false] Use ssl connection (needs to have a mongod server with ssl support)
+ * @param {boolean|function} [options.checkServerIdentity=true] Ensure we check server identify during SSL, set to false to disable checking. Only works for Node 0.12.x or higher. You can pass in a boolean or your own checkServerIdentity override function.
  * @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 
+ * @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
@@ -70,7 +75,7 @@ var Mongos = function(servers, options) {
   // 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");
+      throw MongoError.create({message: "all seed list instances must be of the Server type", driver:true});
     }
   }
 
@@ -98,7 +103,7 @@ var Mongos = function(servers, options) {
   var finalOptions = shallowClone(options);
 
   // Default values
-  finalOptions.size = typeof options.poolSize == 'number' ? options.poolSize : 5;  
+  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;
@@ -106,6 +111,14 @@ var Mongos = function(servers, options) {
   // Add the store
   finalOptions.disconnectHandler = store;
 
+  // Ensure we change the sslCA option to ca if available
+  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;
+  if(options.checkServerIdentity) finalOptions.checkServerIdentity = options.checkServerIdentity;
+
   // Socket options passed down
   if(options.socketOptions) {
     if(options.socketOptions.connectTimeoutMS) {
@@ -114,7 +127,7 @@ var Mongos = function(servers, options) {
     }
     if(options.socketOptions.socketTimeoutMS)
       finalOptions.socketTimeout = options.socketOptions.socketTimeoutMS;
-  } 
+  }
 
   // Are we running in debug mode
   var debug = typeof options.debug == 'boolean' ? options.debug : false;
@@ -185,13 +198,15 @@ var Mongos = function(servers, options) {
 
   // Last ismaster
   Object.defineProperty(this, 'numberOfConnectedServers', {
-    enumerable:true, get: function() { return self.s.mongos.connectedServers().length; }
+    enumerable:true, get: function() {
+      return self.s.mongos.s.mongosState.connectedServers().length;
+    }
   });
 
   // BSON property
-  Object.defineProperty(this, 'bson', { 
-    enumerable: true, get: function() { 
-      return self.s.mongos.bson; 
+  Object.defineProperty(this, 'bson', {
+    enumerable: true, get: function() {
+      return self.s.mongos.bson;
     }
   });
 
@@ -205,6 +220,8 @@ var Mongos = function(servers, options) {
  */
 inherits(Mongos, EventEmitter);
 
+var define = Mongos.define = new Define('Mongos', Mongos, false);
+
 // Connect
 Mongos.prototype.connect = function(db, _options, callback) {
   var self = this;
@@ -230,7 +247,7 @@ Mongos.prototype.connect = function(db, _options, callback) {
       // Try to callback
       try {
         callback(err);
-      } catch(err) { 
+      } catch(err) {
         process.nextTick(function() { throw err; })
       }
     }
@@ -276,14 +293,14 @@ Mongos.prototype.connect = function(db, _options, callback) {
     self.s.mongos.on('fullsetup', relay('fullsetup'));
 
     // Emit open event
-    self.emit('open', null, self);      
+    self.emit('open', null, self);
 
     // Return correctly
     try {
       callback(null, self);
-    } catch(err) { 
+    } catch(err) {
       process.nextTick(function() { throw err; })
-    }      
+    }
   }
 
   // Set up listeners
@@ -302,18 +319,25 @@ Mongos.prototype.parserType = function() {
   return this.s.mongos.parserType();
 }
 
+define.classMethod('parserType', {callback: false, promise:false, returns: [String]});
+
 // Server capabilities
 Mongos.prototype.capabilities = function() {
   if(this.s.sCapabilities) return this.s.sCapabilities;
+  if(this.s.mongos.lastIsMaster() == null) return null;
   this.s.sCapabilities = new ServerCapabilities(this.s.mongos.lastIsMaster());
   return this.s.sCapabilities;
 }
 
+define.classMethod('capabilities', {callback: false, promise:false, returns: [ServerCapabilities]});
+
 // Command
 Mongos.prototype.command = function(ns, cmd, options, callback) {
   this.s.mongos.command(ns, cmd, options, callback);
 }
 
+define.classMethod('command', {callback: true, promise:false});
+
 // Insert
 Mongos.prototype.insert = function(ns, ops, options, callback) {
   this.s.mongos.insert(ns, ops, options, function(e, m) {
@@ -321,30 +345,45 @@ Mongos.prototype.insert = function(ns, ops, options, callback) {
   });
 }
 
+define.classMethod('insert', {callback: true, promise:false});
+
 // Update
 Mongos.prototype.update = function(ns, ops, options, callback) {
   this.s.mongos.update(ns, ops, options, callback);
 }
 
+define.classMethod('update', {callback: true, promise:false});
+
 // Remove
 Mongos.prototype.remove = function(ns, ops, options, callback) {
   this.s.mongos.remove(ns, ops, options, callback);
 }
 
+define.classMethod('remove', {callback: true, promise:false});
+
+// Destroyed
+Mongos.prototype.isDestroyed = function() {
+  return this.s.mongos.isDestroyed();
+}
+
 // IsConnected
 Mongos.prototype.isConnected = function() {
   return this.s.mongos.isConnected();
 }
 
+define.classMethod('isConnected', {callback: false, promise:false, returns: [Boolean]});
+
 // Insert
 Mongos.prototype.cursor = function(ns, cmd, options) {
   options.disconnectHandler = this.s.store;
   return this.s.mongos.cursor(ns, cmd, options);
 }
 
+define.classMethod('cursor', {callback: false, promise:false, returns: [Cursor, AggregationCursor, CommandCursor]});
+
 Mongos.prototype.setBSONParserType = function(type) {
   return this.s.mongos.setBSONParserType(type);
-}  
+}
 
 Mongos.prototype.lastIsMaster = function() {
   return this.s.mongos.lastIsMaster();
@@ -359,11 +398,15 @@ Mongos.prototype.close = function(forceClosed) {
   }
 }
 
+define.classMethod('close', {callback: false, promise:false});
+
 Mongos.prototype.auth = function() {
   var args = Array.prototype.slice.call(arguments, 0);
   this.s.mongos.auth.apply(this.s.mongos, args);
 }
 
+define.classMethod('auth', {callback: true, promise:false});
+
 /**
  * All raw connections
  * @method
@@ -371,7 +414,9 @@ Mongos.prototype.auth = function() {
  */
 Mongos.prototype.connections = function() {
   return this.s.mongos.connections();
-}      
+}
+
+define.classMethod('connections', {callback: false, promise:false, returns:[Array]});
 
 /**
  * A mongos connect event, used to verify that the connection is up and running