Node.js MongoDB Driver API

Source: lib/mongo_client.js

  1. "use strict";
  3. var parse = require('./url_parser')
  4.   , Server = require('./server')
  5.   , Mongos = require('./mongos')
  6.   , ReplSet = require('./replset')
  7.   , EventEmitter = require('events').EventEmitter
  8.   , inherits = require('util').inherits
  9.   , Define = require('./metadata')
  10.   , ReadPreference = require('./read_preference')
  11.   , Logger = require('mongodb-core').Logger
  12.   , MongoError = require('mongodb-core').MongoError
  13.   , Db = require('./db')
  14.   , f = require('util').format
  15.   , assign = require('./utils').assign
  16.   , shallowClone = require('./utils').shallowClone
  17.   , authenticate = require('./authenticate');
  19. /**
  20.  * @fileOverview The **MongoClient** class is a class that allows for making Connections to MongoDB.
  21.  *
  22.  * @example
  23.  * var MongoClient = require('mongodb').MongoClient,
  24.  *   test = require('assert');
  25.  * // Connection url
  26.  * var url = 'mongodb://localhost:27017/test';
  27.  * // Connect using MongoClient
  28.  * MongoClient.connect(url, function(err, db) {
  29.  *   // Get an additional db
  30.  *   db.close();
  31.  * });
  32.  */
  33. var validOptionNames = ['poolSize', 'ssl', 'sslValidate', 'sslCA', 'sslCert', 'ciphers', 'ecdhCurve',
  34.   'sslKey', 'sslPass', 'sslCRL', 'autoReconnect', 'noDelay', 'keepAlive', 'connectTimeoutMS', 'family',
  35.   'socketTimeoutMS', 'reconnectTries', 'reconnectInterval', 'ha', 'haInterval',
  36.   'replicaSet', 'secondaryAcceptableLatencyMS', 'acceptableLatencyMS',
  37.   'connectWithNoPrimary', 'authSource', 'w', 'wtimeout', 'j', 'forceServerObjectId',
  38.   'serializeFunctions', 'ignoreUndefined', 'raw', 'bufferMaxEntries',
  39.   'readPreference', 'pkFactory', 'promiseLibrary', 'readConcern', 'maxStalenessSeconds',
  40.   'loggerLevel', 'logger', 'promoteValues', 'promoteBuffers', 'promoteLongs',
  41.   'domainsEnabled', 'keepAliveInitialDelay', 'checkServerIdentity', 'validateOptions', 'appname', 'auth'];
  42. var ignoreOptionNames = ['native_parser'];
  43. var legacyOptionNames = ['server', 'replset', 'replSet', 'mongos', 'db'];
  45. function validOptions(options) {
  46.   var _validOptions = validOptionNames.concat(legacyOptionNames);
  48.   for(var name in options) {
  49.     if(ignoreOptionNames.indexOf(name) != -1) {
  50.       continue;
  51.     }
  53.     if(_validOptions.indexOf(name) == -1 && options.validateOptions) {
  54.       return new MongoError(f('option %s is not supported', name));
  55.     } else if(_validOptions.indexOf(name) == -1) {
  56.       console.warn(f('the options [%s] is not supported', name));
  57.     }
  59.     if(legacyOptionNames.indexOf(name) != -1) {
  60.       console.warn(f('the server/replset/mongos options are deprecated, '
  61.       + 'all their options are supported at the top level of the options object [%s]', validOptionNames));
  62.     }
  63.   }
  64. }
  66. /**
  67.  * Creates a new MongoClient instance
  68.  * @class
  69.  * @return {MongoClient} a MongoClient instance.
  70.  */
  71. function MongoClient() {
  72.   if(!(this instanceof MongoClient)) return new MongoClient();
  74.   // Set up event emitter
  75.   EventEmitter.call(this);
  77.   /**
  78.    * The callback format for results
  79.    * @callback MongoClient~connectCallback
  80.    * @param {MongoError} error An error instance representing the error during the execution.
  81.    * @param {Db} db The connected database.
  82.    */
  84.   /**
  85.    * Connect to MongoDB using a url as documented at
  86.    *
  87.    *  docs.mongodb.org/manual/reference/connection-string/
  88.    *
  89.    * Note that for replicasets the replicaSet query parameter is required in the 2.0 driver
  90.    *
  91.    * @method
  92.    * @param {string} url The connection URI string
  93.    * @param {object} [options] Optional settings.
  94.    * @param {number} [options.poolSize=5] poolSize The maximum size of the individual server pool.
  95.    * @param {boolean} [options.ssl=false] Enable SSL connection.
  96.    * @param {Buffer} [options.sslCA=undefined] SSL Certificate store binary buffer
  97.    * @param {Buffer} [options.sslCRL=undefined] SSL Certificate revocation list binary buffer
  98.    * @param {Buffer} [options.sslCert=undefined] SSL Certificate binary buffer
  99.    * @param {Buffer} [options.sslKey=undefined] SSL Key file binary buffer
  100.    * @param {string} [options.sslPass=undefined] SSL Certificate pass phrase
  101.    * @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.
  102.    * @param {boolean} [options.autoReconnect=true] Enable autoReconnect for single server instances
  103.    * @param {boolean} [options.noDelay=true] TCP Connection no delay
  104.    * @param {number} [options.family=4] Version of IP stack. Defaults to 4.
  105.    * @param {number} [options.keepAlive=30000] The number of milliseconds to wait before initiating keepAlive on the TCP socket.
  106.    * @param {number} [options.connectTimeoutMS=30000] TCP Connection timeout setting
  107.    * @param {number} [options.socketTimeoutMS=360000] TCP Socket timeout setting
  108.    * @param {number} [options.reconnectTries=30] Server attempt to reconnect #times
  109.    * @param {number} [options.reconnectInterval=1000] Server will wait # milliseconds between retries
  110.    * @param {boolean} [options.ha=true] Control if high availability monitoring runs for Replicaset or Mongos proxies.
  111.    * @param {number} [options.haInterval=10000] The High availability period for replicaset inquiry
  112.    * @param {string} [options.replicaSet=undefined] The Replicaset set name
  113.    * @param {number} [options.secondaryAcceptableLatencyMS=15] Cutoff latency point in MS for Replicaset member selection
  114.    * @param {number} [options.acceptableLatencyMS=15] Cutoff latency point in MS for Mongos proxies selection.
  115.    * @param {boolean} [options.connectWithNoPrimary=false] Sets if the driver should connect even if no primary is available
  116.    * @param {string} [options.authSource=undefined] Define the database to authenticate against
  117.    * @param {string} [options.auth.user=undefined] The username for auth
  118.    * @param {string} [options.auth.password=undefined] The password for auth
  119.    * @param {(number|string)} [options.w=null] The write concern.
  120.    * @param {number} [options.wtimeout=null] The write concern timeout.
  121.    * @param {boolean} [options.j=false] Specify a journal write concern.
  122.    * @param {boolean} [options.forceServerObjectId=false] Force server to assign _id values instead of driver.
  123.    * @param {boolean} [options.serializeFunctions=false] Serialize functions on any object.
  124.    * @param {Boolean} [options.ignoreUndefined=false] Specify if the BSON serializer should ignore undefined fields.
  125.    * @param {boolean} [options.raw=false] Return document results as raw BSON buffers.
  126.    * @param {boolean} [options.promoteLongs=true] Promotes Long values to number if they fit inside the 53 bits resolution.
  127.    * @param {boolean} [options.promoteBuffers=false] Promotes Binary BSON values to native Node Buffers.
  128.    * @param {boolean} [options.promoteValues=true] Promotes BSON values to native types where possible, set to false to only receive wrapper types.
  129.    * @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.
  130.    * @param {(ReadPreference|string)} [options.readPreference=null] The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).
  131.    * @param {boolean} [options.domainsEnabled=false] Enable the wrapping of the callback in the current domain, disabled by default to avoid perf hit.
  132.    * @param {object} [options.pkFactory=null] A primary key factory object for generation of custom _id keys.
  133.    * @param {object} [options.promiseLibrary=null] A Promise library class the application wishes to use such as Bluebird, must be ES6 compatible
  134.    * @param {object} [options.readConcern=null] Specify a read concern for the collection. (only MongoDB 3.2 or higher supported)
  135.    * @param {string} [options.readConcern.level='local'] Specify a read concern level for the collection operations, one of [local|majority]. (only MongoDB 3.2 or higher supported)
  136.    * @param {number} [options.maxStalenessSeconds=undefined] The max staleness to secondary reads (values under 10 seconds cannot be guaranteed);
  137.    * @param {string} [options.appname=undefined] The name of the application that created this MongoClient instance. MongoDB 3.4 and newer will print this value in the server log upon establishing each connection. It is also recorded in the slow query log and profile collections.
  138.    * @param {string} [options.loggerLevel=undefined] The logging level (error/warn/info/debug)
  139.    * @param {object} [options.logger=undefined] Custom logger object
  140.    * @param {object} [options.validateOptions=false] Validate MongoClient passed in options for correctness.
  141.    * @param {MongoClient~connectCallback} [callback] The command result callback
  142.    * @return {Promise} returns Promise if no callback passed
  143.    */
  144.   this.connect = MongoClient.connect;
  145. }
  147. /**
  148.  * @ignore
  149.  */
  150. inherits(MongoClient, EventEmitter);
  152. var define = MongoClient.define = new Define('MongoClient', MongoClient, false);
  154. /**
  155.  * Connect to MongoDB using a url as documented at
  156.  *
  157.  *  docs.mongodb.org/manual/reference/connection-string/
  158.  *
  159.  * Note that for replicasets the replicaSet query parameter is required in the 2.0 driver
  160.  *
  161.  * @method
  162.  * @static
  163.  * @param {string} url The connection URI string
  164.  * @param {object} [options] Optional settings.
  165.  * @param {number} [options.poolSize=5] poolSize The maximum size of the individual server pool.
  166.  * @param {boolean} [options.ssl=false] Enable SSL connection.
  167.  * @param {Buffer} [options.sslCA=undefined] SSL Certificate store binary buffer
  168.  * @param {Buffer} [options.sslCRL=undefined] SSL Certificate revocation list binary buffer
  169.  * @param {Buffer} [options.sslCert=undefined] SSL Certificate binary buffer
  170.  * @param {Buffer} [options.sslKey=undefined] SSL Key file binary buffer
  171.  * @param {string} [options.sslPass=undefined] SSL Certificate pass phrase
  172.  * @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.
  173.  * @param {boolean} [options.autoReconnect=true] Enable autoReconnect for single server instances
  174.  * @param {boolean} [options.noDelay=true] TCP Connection no delay
  175.  * @param {number} [options.family=4] Version of IP stack. Defaults to 4.
  176.  * @param {boolean} [options.keepAlive=30000] The number of milliseconds to wait before initiating keepAlive on the TCP socket.
  177.  * @param {number} [options.connectTimeoutMS=30000] TCP Connection timeout setting
  178.  * @param {number} [options.socketTimeoutMS=360000] TCP Socket timeout setting
  179.  * @param {number} [options.reconnectTries=30] Server attempt to reconnect #times
  180.  * @param {number} [options.reconnectInterval=1000] Server will wait # milliseconds between retries
  181.  * @param {boolean} [options.ha=true] Control if high availability monitoring runs for Replicaset or Mongos proxies.
  182.  * @param {number} [options.haInterval=10000] The High availability period for replicaset inquiry
  183.  * @param {string} [options.replicaSet=undefined] The Replicaset set name
  184.  * @param {number} [options.secondaryAcceptableLatencyMS=15] Cutoff latency point in MS for Replicaset member selection
  185.  * @param {number} [options.acceptableLatencyMS=15] Cutoff latency point in MS for Mongos proxies selection.
  186.  * @param {boolean} [options.connectWithNoPrimary=false] Sets if the driver should connect even if no primary is available
  187.  * @param {string} [options.authSource=undefined] Define the database to authenticate against
  188.  * @param {string} [options.auth.user=undefined] The username for auth
  189.  * @param {string} [options.auth.password=undefined] The password for auth
  190.  * @param {(number|string)} [options.w=null] The write concern.
  191.  * @param {number} [options.wtimeout=null] The write concern timeout.
  192.  * @param {boolean} [options.j=false] Specify a journal write concern.
  193.  * @param {boolean} [options.forceServerObjectId=false] Force server to assign _id values instead of driver.
  194.  * @param {boolean} [options.serializeFunctions=false] Serialize functions on any object.
  195.  * @param {Boolean} [options.ignoreUndefined=false] Specify if the BSON serializer should ignore undefined fields.
  196.  * @param {boolean} [options.raw=false] Return document results as raw BSON buffers.
  197.  * @param {boolean} [options.promoteLongs=true] Promotes Long values to number if they fit inside the 53 bits resolution.
  198.  * @param {boolean} [options.promoteBuffers=false] Promotes Binary BSON values to native Node Buffers.
  199.  * @param {boolean} [options.promoteValues=true] Promotes BSON values to native types where possible, set to false to only receive wrapper types.
  200.  * @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.
  201.  * @param {(ReadPreference|string)} [options.readPreference=null] The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).
  202.  * @param {boolean} [options.domainsEnabled=false] Enable the wrapping of the callback in the current domain, disabled by default to avoid perf hit.
  203.  * @param {object} [options.pkFactory=null] A primary key factory object for generation of custom _id keys.
  204.  * @param {object} [options.promiseLibrary=null] A Promise library class the application wishes to use such as Bluebird, must be ES6 compatible
  205.  * @param {object} [options.readConcern=null] Specify a read concern for the collection. (only MongoDB 3.2 or higher supported)
  206.  * @param {string} [options.readConcern.level='local'] Specify a read concern level for the collection operations, one of [local|majority]. (only MongoDB 3.2 or higher supported)
  207.  * @param {number} [options.maxStalenessSeconds=undefined] The max staleness to secondary reads (values under 10 seconds cannot be guaranteed);
  208.  * @param {string} [options.appname=undefined] The name of the application that created this MongoClient instance. MongoDB 3.4 and newer will print this value in the server log upon establishing each connection. It is also recorded in the slow query log and profile collections.
  209.  * @param {string} [options.loggerLevel=undefined] The logging level (error/warn/info/debug)
  210.  * @param {object} [options.logger=undefined] Custom logger object
  211.  * @param {object} [options.validateOptions=false] Validate MongoClient passed in options for correctness.
  212.  * @param {MongoClient~connectCallback} [callback] The command result callback
  213.  * @return {Promise} returns Promise if no callback passed
  214.  */
  215. MongoClient.connect = function(url, options, callback) {
  216.   var args = Array.prototype.slice.call(arguments, 1);
  217.   callback = typeof args[args.length - 1] == 'function' ? args.pop() : null;
  218.   options = args.length ? args.shift() : null;
  219.   options = options || {};
  220.   var self = this;
  222.   // Validate options object
  223.   var err = validOptions(options);
  225.   // Get the promiseLibrary
  226.   var promiseLibrary = options.promiseLibrary;
  228.   // No promise library selected fall back
  229.   if(!promiseLibrary) {
  230.     promiseLibrary = typeof global.Promise == 'function' ?
  231.       global.Promise : require('es6-promise').Promise;
  232.   }
  234.   // Return a promise
  235.   if(typeof callback != 'function') {
  236.     return new promiseLibrary(function(resolve, reject) {
  237.       // Did we have a validation error
  238.       if(err) return reject(err);
  239.       // Attempt to connect
  240.       connect(self, url, options, function(err, db) {
  241.         if(err) return reject(err);
  242.         resolve(db);
  243.       });
  244.     });
  245.   }
  247.   // Did we have a validation error
  248.   if(err) return callback(err);
  249.   // Fallback to callback based connect
  250.   connect(self, url, options, callback);
  251. }
  253. define.staticMethod('connect', {callback: true, promise:true});
  255. var mergeOptions = function(target, source, flatten) {
  256.   for(var name in source) {
  257.     if(source[name] && typeof source[name] == 'object' && flatten) {
  258.       target = mergeOptions(target, source[name], flatten);
  259.     } else {
  260.       target[name] = source[name];
  261.     }
  262.   }
  264.   return target;
  265. }
  267. var createUnifiedOptions = function(finalOptions, options) {
  268.   var childOptions = ['mongos', 'server', 'db'
  269.     , 'replset', 'db_options', 'server_options', 'rs_options', 'mongos_options'];
  270.   var noMerge = ['readconcern'];
  272.   for(var name in options) {
  273.     if(noMerge.indexOf(name.toLowerCase()) != -1) {
  274.       finalOptions[name] = options[name];
  275.     } else if(childOptions.indexOf(name.toLowerCase()) != -1) {
  276.       finalOptions = mergeOptions(finalOptions, options[name], false);
  277.     } else {
  278.       if(options[name] && typeof options[name] == 'object' && !Buffer.isBuffer(options[name]) && !Array.isArray(options[name])) {
  279.         finalOptions = mergeOptions(finalOptions, options[name], true);
  280.       } else {
  281.         finalOptions[name] = options[name];
  282.       }
  283.     }
  284.   }
  286.   return finalOptions;
  287. }
  289. function translateOptions(options) {
  290.   // If we have a readPreference passed in by the db options
  291.   if(typeof options.readPreference == 'string' || typeof options.read_preference == 'string') {
  292.     options.readPreference = new ReadPreference(options.readPreference || options.read_preference);
  293.   }
  295.   // Do we have readPreference tags, add them
  296.   if(options.readPreference && (options.readPreferenceTags || options.read_preference_tags)) {
  297.     options.readPreference.tags = options.readPreferenceTags || options.read_preference_tags;
  298.   }
  300.   // Do we have maxStalenessSeconds
  301.   if(options.maxStalenessSeconds) {
  302.     options.readPreference.maxStalenessSeconds = options.maxStalenessSeconds;
  303.   }
  305.   // Set the socket and connection timeouts
  306.   if(options.socketTimeoutMS == null) options.socketTimeoutMS = 360000;
  307.   if(options.connectTimeoutMS == null) options.connectTimeoutMS = 30000;
  309.   // Create server instances
  310.   return options.servers.map(function(serverObj) {
  311.     return serverObj.domain_socket ?
  312.       new Server(serverObj.domain_socket, 27017, options)
  313.     : new Server(serverObj.host, serverObj.port, options);
  314.   });
  315. }
  317. //
  318. // Collect all events in order from SDAM
  319. //
  320. function collectEvents(self, db) {
  321.   var collectedEvents = [];
  323.   if(self instanceof MongoClient) {
  324.     var events = ["timeout", "close", 'serverOpening', 'serverDescriptionChanged', 'serverHeartbeatStarted',
  325.       'serverHeartbeatSucceeded', 'serverHeartbeatFailed', 'serverClosed', 'topologyOpening',
  326.       'topologyClosed', 'topologyDescriptionChanged', 'joined', 'left', 'ping', 'ha', 'all', 'fullsetup'];
  327.     events.forEach(function(event) {
  328.       db.serverConfig.on(event, function(object1, object2) {
  329.         collectedEvents.push({
  330.           event: event, object1: object1, object2: object2
  331.         });
  332.       });
  333.     });
  334.   }
  336.   return collectedEvents;
  337. }
  339. //
  340. // Replay any events due to single server connection switching to Mongos
  341. //
  342. function replayEvents(self, events) {
  343.   for(var i = 0; i < events.length; i++) {
  344.     self.emit(events[i].event, events[i].object1, events[i].object2);
  345.   }
  346. }
  348. function relayEvents(self, db) {
  349.   if(self instanceof MongoClient) {
  350.     var events = ["timeout", "close", 'serverOpening', 'serverDescriptionChanged', 'serverHeartbeatStarted',
  351.       'serverHeartbeatSucceeded', 'serverHeartbeatFailed', 'serverClosed', 'topologyOpening',
  352.       'topologyClosed', 'topologyDescriptionChanged', 'joined', 'left', 'ping', 'ha', 'all', 'fullsetup'];
  353.     events.forEach(function(event) {
  354.       db.serverConfig.on(event, function(object1, object2) {
  355.         self.emit(event, object1, object2);
  356.       });
  357.     });
  358.   }
  359. }
  361. function createReplicaset(self, options, callback) {
  362.   // Set default options
  363.   var servers = translateOptions(options);
  364.   // Create Db instance
  365.   var db = new Db(options.dbName, new ReplSet(servers, options), options);
  366.   // Propegate the events to the client
  367.   relayEvents(self, db);
  368.   // Open the connection
  369.   db.open(callback);
  370. }
  372. function createMongos(self, options, callback) {
  373.   // Set default options
  374.   var servers = translateOptions(options);
  375.   // Create Db instance
  376.   var db = new Db(options.dbName, new Mongos(servers, options), options)
  377.   // Propegate the events to the client
  378.   relayEvents(self, db);
  379.   // Open the connection
  380.   db.open(callback);
  381. }
  383. function createServer(self, options, callback) {
  384.   // Set default options
  385.   var servers = translateOptions(options);
  386.   // Create db instance
  387.   var db = new Db(options.dbName, servers[0], options);
  388.   // Propegate the events to the client
  389.   var collectedEvents = collectEvents(self, db);
  390.   // Create Db instance
  391.   db.open(function(err, db) {
  392.     if(err) return callback(err);
  393.     // Check if we are really speaking to a mongos
  394.     var ismaster = db.serverConfig.lastIsMaster();
  396.     // Do we actually have a mongos
  397.     if(ismaster && ismaster.msg == 'isdbgrid') {
  398.       // Destroy the current connection
  399.       db.close();
  400.       // Create mongos connection instead
  401.       return createMongos(self, options, callback);
  402.     }
  404.     // Fire all the events
  405.     replayEvents(self, collectedEvents);
  406.     // Propegate the events to the client
  407.     relayEvents(self, db);
  408.     // Otherwise callback
  409.     callback(err, db);
  410.   });
  411. }
  413. function connectHandler(options, callback) {
  414.   return function (err, db) {
  415.     if(err) {
  416.       return process.nextTick(function() {
  417.         try {
  418.           callback(err, null);
  419.         } catch (err) {
  420.           if(db) db.close();
  421.           throw err
  422.         }
  423.       });
  424.     }
  426.     // No authentication just reconnect
  427.     if(!options.auth) {
  428.       return process.nextTick(function() {
  429.         try {
  430.           callback(err, db);
  431.         } catch (err) {
  432.           if(db) db.close();
  433.           throw err
  434.         }
  435.       })
  436.     }
  438.     // What db to authenticate against
  439.     var authentication_db = db;
  440.     if(options.authSource) {
  441.       authentication_db = db.db(options.authSource);
  442.     }
  444.     // Authenticate
  445.     authenticate(authentication_db, options.user, options.password, options, function(err, success) {
  446.       if(success){
  447.         process.nextTick(function() {
  448.           try {
  449.             callback(null, db);
  450.           } catch (err) {
  451.             if(db) db.close();
  452.             throw err
  453.           }
  454.         });
  455.       } else {
  456.         if(db) db.close();
  457.         process.nextTick(function() {
  458.           try {
  459.             callback(err ? err : new Error('Could not authenticate user ' + options.auth[0]), null);
  460.           } catch (err) {
  461.             if(db) db.close();
  462.             throw err
  463.           }
  464.         });
  465.       }
  466.     });
  467.   }
  468. }
  470. /*
  471.  * Connect using MongoClient
  472.  */
  473. var connect = function(self, url, options, callback) {
  474.   options = options || {};
  475.   options = shallowClone(options);
  477.   // If callback is null throw an exception
  478.   if(callback == null) {
  479.     throw new Error("no callback function provided");
  480.   }
  482.   // Get a logger for MongoClient
  483.   var logger = Logger('MongoClient', options);
  485.   parse(url, options, function(err, object) {
  486.     if (err) return callback(err);
  488.     // Parse the string
  489.     var _finalOptions = createUnifiedOptions({}, object);
  490.     _finalOptions = mergeOptions(_finalOptions, object, false);
  491.     _finalOptions = createUnifiedOptions(_finalOptions, options);
  493.     // Check if we have connection and socket timeout set
  494.     if(_finalOptions.socketTimeoutMS == null) _finalOptions.socketTimeoutMS = 360000;
  495.     if(_finalOptions.connectTimeoutMS == null) _finalOptions.connectTimeoutMS = 30000;
  497.     if (_finalOptions.db_options && _finalOptions.db_options.auth) {
  498.       delete _finalOptions.db_options.auth;
  499.     }
  501.     // Failure modes
  502.     if(object.servers.length == 0) {
  503.       throw new Error("connection string must contain at least one seed host");
  504.     }
  506.     // Do we have a replicaset then skip discovery and go straight to connectivity
  507.     if(_finalOptions.replicaSet || _finalOptions.rs_name) {
  508.       return createReplicaset(self, _finalOptions, connectHandler(_finalOptions, connectCallback));
  509.     } else if(object.servers.length > 1) {
  510.       return createMongos(self, _finalOptions, connectHandler(_finalOptions, connectCallback));
  511.     } else {
  512.       return createServer(self, _finalOptions, connectHandler(_finalOptions, connectCallback));
  513.     }
  514.   });
  516.   function connectCallback(err, db) {
  517.     if(err && err.message == 'no mongos proxies found in seed list') {
  518.       if(logger.isWarn()) {
  519.         logger.warn(f('seed list contains no mongos proxies, replicaset connections requires the parameter replicaSet to be supplied in the URI or options object, mongodb://server:port/db?replicaSet=name'));
  520.       }
  522.       // Return a more specific error message for MongoClient.connect
  523.       return callback(new MongoError('seed list contains no mongos proxies, replicaset connections requires the parameter replicaSet to be supplied in the URI or options object, mongodb://server:port/db?replicaSet=name'));
  524.     }
  526.     // Return the error and db instance
  527.     callback(err, db);
  528.   }
  529. }
  531. module.exports = MongoClient