Node.js MongoDB Driver API

Source: lib/server.js

  1. "use strict";
  3. var EventEmitter = require('events').EventEmitter
  4.   , inherits = require('util').inherits
  5.   , CServer = require('mongodb-core').Server
  6.   , Cursor = require('./cursor')
  7.   , AggregationCursor = require('./aggregation_cursor')
  8.   , CommandCursor = require('./command_cursor')
  9.   , f = require('util').format
  10.   , ServerCapabilities = require('./topology_base').ServerCapabilities
  11.   , Store = require('./topology_base').Store
  12.   , Define = require('./metadata')
  13.   , MongoError = require('mongodb-core').MongoError
  14.   , MAX_JS_INT = require('./utils').MAX_JS_INT
  15.   , translateOptions = require('./utils').translateOptions
  16.   , filterOptions = require('./utils').filterOptions
  17.   , mergeOptions = require('./utils').mergeOptions
  18.   , getReadPreference = require('./utils').getReadPreference
  19.   , os = require('os');
  21. // Get package.json variable
  22. var driverVersion = require('../package.json').version;
  23. var nodejsversion = f('Node.js %s, %s', process.version, os.endianness());
  24. var type = os.type();
  25. var name = process.platform;
  26. var architecture = process.arch;
  27. var release = os.release();
  29. /**
  30.  * @fileOverview The **Server** class is a class that represents a single server topology and is
  31.  * used to construct connections.
  32.  *
  33.  * **Server Should not be used, use MongoClient.connect**
  34.  * @example
  35.  * var Db = require('mongodb').Db,
  36.  *   Server = require('mongodb').Server,
  37.  *   test = require('assert');
  38.  * // Connect using single Server
  39.  * var db = new Db('test', new Server('localhost', 27017););
  40.  * db.open(function(err, db) {
  41.  *   // Get an additional db
  42.  *   db.close();
  43.  * });
  44.  */
  46.  // Allowed parameters
  47.  var legalOptionNames = ['ha', 'haInterval', 'acceptableLatencyMS'
  48.    , 'poolSize', 'ssl', 'checkServerIdentity', 'sslValidate', 'ciphers', 'ecdhCurve'
  49.    , 'sslCA', 'sslCRL', 'sslCert', 'sslKey', 'sslPass', 'socketOptions', 'bufferMaxEntries'
  50.    , 'store', 'auto_reconnect', 'autoReconnect', 'emitError'
  51.    , 'keepAlive', 'noDelay', 'connectTimeoutMS', 'socketTimeoutMS', 'family'
  52.    , 'loggerLevel', 'logger', 'reconnectTries', 'reconnectInterval', 'monitoring'
  53.    , 'appname', 'domainsEnabled'
  54.    , 'servername', 'promoteLongs', 'promoteValues', 'promoteBuffers'];
  56. /**
  57.  * Creates a new Server instance
  58.  * @class
  59.  * @deprecated
  60.  * @param {string} host The host for the server, can be either an IP4, IP6 or domain socket style host.
  61.  * @param {number} [port] The server port if IP4.
  62.  * @param {object} [options=null] Optional settings.
  63.  * @param {number} [options.poolSize=5] Number of connections in the connection pool for each server instance, set to 5 as default for legacy reasons.
  64.  * @param {boolean} [options.ssl=false] Use ssl connection (needs to have a mongod server with ssl support)
  65.  * @param {object} [options.sslValidate=true] Validate mongod server certificate against ca (needs to have a mongod server with ssl support, 2.4 or higher)
  66.  * @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.
  67.  * @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)
  68.  * @param {array} [options.sslCRL=null] Array of revocation certificates either as Buffers or Strings (needs to have a mongod server with ssl support, 2.4 or higher)
  69.  * @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)
  70.  * @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)
  71.  * @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)
  72.  * @param {string} [options.servername=null] String containing the server name requested via TLS SNI.
  73.  * @param {boolean} [options.autoReconnect=true] Reconnect on error or timeout.
  74.  * @param {object} [options.socketOptions=null] Socket options
  75.  * @param {boolean} [options.socketOptions.noDelay=true] TCP Socket NoDelay option.
  76.  * @param {number} [options.socketOptions.keepAlive=0] TCP KeepAlive on the socket with a X ms delay before start.
  77.  * @param {number} [options.socketOptions.connectTimeoutMS=0] TCP Connection timeout setting
  78.  * @param {number} [options.socketOptions.socketTimeoutMS=0] TCP Socket timeout setting
  79.  * @param {number} [options.reconnectTries=30] Server attempt to reconnect #times
  80.  * @param {number} [options.reconnectInterval=1000] Server will wait # milliseconds between retries
  81.  * @param {number} [options.monitoring=true] Triggers the server instance to call ismaster
  82.  * @param {number} [options.haInterval=10000] The interval of calling ismaster when monitoring is enabled.
  83.  * @param {boolean} [options.domainsEnabled=false] Enable the wrapping of the callback in the current domain, disabled by default to avoid perf hit.
  84.  * @fires Server#connect
  85.  * @fires Server#close
  86.  * @fires Server#error
  87.  * @fires Server#timeout
  88.  * @fires Server#parseError
  89.  * @fires Server#reconnect
  90.  * @property {string} parserType the parser type used (c++ or js).
  91.  * @return {Server} a Server instance.
  92.  */
  93. var Server = function(host, port, options) {
  94.   options = options || {};
  95.   if(!(this instanceof Server)) return new Server(host, port, options);
  96.   EventEmitter.call(this);
  97.   var self = this;
  99.   // Filter the options
  100.   options = filterOptions(options, legalOptionNames);
  102.   // Stored options
  103.   var storeOptions = {
  104.       force: false
  105.     , bufferMaxEntries: typeof options.bufferMaxEntries == 'number' ? options.bufferMaxEntries : MAX_JS_INT
  106.   }
  108.   // Shared global store
  109.   var store = options.store || new Store(self, storeOptions);
  111.   // Detect if we have a socket connection
  112.   if(host.indexOf('\/') != -1) {
  113.     if(port != null && typeof port == 'object') {
  114.       options = port;
  115.       port = null;
  116.     }
  117.   } else if(port == null) {
  118.     throw MongoError.create({message: 'port must be specified', driver:true});
  119.   }
  121.   // Get the reconnect option
  122.   var reconnect = typeof options.auto_reconnect == 'boolean' ? options.auto_reconnect : true;
  123.   reconnect = typeof options.autoReconnect == 'boolean' ? options.autoReconnect : reconnect;
  125.   // Clone options
  126.   var clonedOptions = mergeOptions({}, {
  127.     host: host, port: port, disconnectHandler: store,
  128.     cursorFactory: Cursor,
  129.     reconnect: reconnect,
  130.     emitError: typeof options.emitError == 'boolean' ? options.emitError : true,
  131.     size: typeof options.poolSize == 'number' ? options.poolSize : 5
  132.   });
  134.   // Translate any SSL options and other connectivity options
  135.   clonedOptions = translateOptions(clonedOptions, options);
  137.   // Socket options
  138.   var socketOptions = options.socketOptions && Object.keys(options.socketOptions).length > 0
  139.     ? options.socketOptions : options;
  141.   // Translate all the options to the mongodb-core ones
  142.   clonedOptions = translateOptions(clonedOptions, socketOptions);
  143.   if(typeof clonedOptions.keepAlive == 'number') {
  144.     clonedOptions.keepAliveInitialDelay = clonedOptions.keepAlive;
  145.     clonedOptions.keepAlive = clonedOptions.keepAlive > 0;
  146.   }
  148.   // Build default client information
  149.   this.clientInfo = {
  150.     driver: {
  151.       name: "nodejs",
  152.       version: driverVersion
  153.     },
  154.     os: {
  155.       type: type,
  156.       name: name,
  157.       architecture: architecture,
  158.       version: release
  159.     },
  160.     platform: nodejsversion
  161.   }
  163.   // Build default client information
  164.   clonedOptions.clientInfo = this.clientInfo;
  165.   // Do we have an application specific string
  166.   if(options.appname) {
  167.     clonedOptions.clientInfo.application = { name: options.appname };
  168.   }
  170.   // Create an instance of a server instance from mongodb-core
  171.   var server = new CServer(clonedOptions);
  173.   // Define the internal properties
  174.   this.s = {
  175.     // Create an instance of a server instance from mongodb-core
  176.       server: server
  177.     // Server capabilities
  178.     , sCapabilities: null
  179.     // Cloned options
  180.     , clonedOptions: clonedOptions
  181.     // Reconnect
  182.     , reconnect: clonedOptions.reconnect
  183.     // Emit error
  184.     , emitError: clonedOptions.emitError
  185.     // Pool size
  186.     , poolSize: clonedOptions.size
  187.     // Store Options
  188.     , storeOptions: storeOptions
  189.     // Store
  190.     , store: store
  191.     // Host
  192.     , host: host
  193.     // Port
  194.     , port: port
  195.     // Options
  196.     , options: options
  197.   }
  198. }
  200. inherits(Server, EventEmitter);
  202. var define = Server.define = new Define('Server', Server, false);
  204. // BSON property
  205. Object.defineProperty(Server.prototype, 'bson', {
  206.   enumerable: true, get: function() {
  207.     return this.s.server.s.bson;
  208.   }
  209. });
  211. // Last ismaster
  212. Object.defineProperty(Server.prototype, 'isMasterDoc', {
  213.   enumerable:true, get: function() {
  214.     return this.s.server.lastIsMaster();
  215.   }
  216. });
  218. Object.defineProperty(Server.prototype, 'parserType', {
  219.   enumerable:true, get: function() {
  220.     return this.s.server.parserType;
  221.   }
  222. });
  224. // Last ismaster
  225. Object.defineProperty(Server.prototype, 'poolSize', {
  226.   enumerable:true, get: function() { return this.s.server.connections().length; }
  227. });
  229. Object.defineProperty(Server.prototype, 'autoReconnect', {
  230.   enumerable:true, get: function() { return this.s.reconnect; }
  231. });
  233. Object.defineProperty(Server.prototype, 'host', {
  234.   enumerable:true, get: function() { return this.s.host; }
  235. });
  237. Object.defineProperty(Server.prototype, 'port', {
  238.   enumerable:true, get: function() { return this.s.port; }
  239. });
  241. // Connect
  242. Server.prototype.connect = function(db, _options, callback) {
  243.   var self = this;
  244.   if('function' === typeof _options) callback = _options, _options = {};
  245.   if(_options == null) _options = {};
  246.   if(!('function' === typeof callback)) callback = null;
  247.   self.s.options = _options;
  249.   // Update bufferMaxEntries
  250.   self.s.storeOptions.bufferMaxEntries = db.bufferMaxEntries;
  252.   // Error handler
  253.   var connectErrorHandler = function() {
  254.     return function(err) {
  255.       // Remove all event handlers
  256.       var events = ['timeout', 'error', 'close'];
  257.       events.forEach(function(e) {
  258.         self.s.server.removeListener(e, connectHandlers[e]);
  259.       });
  261.       self.s.server.removeListener('connect', connectErrorHandler);
  263.       // Try to callback
  264.       try {
  265.         callback(err);
  266.       } catch(err) {
  267.         process.nextTick(function() { throw err; })
  268.       }
  269.     }
  270.   }
  272.   // Actual handler
  273.   var errorHandler = function(event) {
  274.     return function(err) {
  275.       if(event != 'error') {
  276.         self.emit(event, err);
  277.       }
  278.     }
  279.   }
  281.   // Error handler
  282.   var reconnectHandler = function() {
  283.     self.emit('reconnect', self);
  284.     self.s.store.execute();
  285.   }
  287.   // Reconnect failed
  288.   var reconnectFailedHandler = function(err) {
  289.     self.emit('reconnectFailed', err);
  290.     self.s.store.flush(err);
  291.   }
  293.   // Destroy called on topology, perform cleanup
  294.   var destroyHandler = function() {
  295.     self.s.store.flush();
  296.   }
  298.   // relay the event
  299.   var relay = function(event) {
  300.     return function(t, server) {
  301.       self.emit(event, t, server);
  302.     }
  303.   }
  305.   // Connect handler
  306.   var connectHandler = function() {
  307.     // Clear out all the current handlers left over
  308.     ["timeout", "error", "close", 'destroy'].forEach(function(e) {
  309.       self.s.server.removeAllListeners(e);
  310.     });
  312.     // Set up listeners
  313.     self.s.server.on('timeout', errorHandler('timeout'));
  314.     self.s.server.once('error', errorHandler('error'));
  315.     self.s.server.on('close', errorHandler('close'));
  316.     // Only called on destroy
  317.     self.s.server.on('destroy', destroyHandler);
  319.     // Emit open event
  320.     self.emit('open', null, self);
  322.     // Return correctly
  323.     try {
  324.       callback(null, self);
  325.     } catch(err) {
  326.       console.log(err.stack)
  327.       process.nextTick(function() { throw err; })
  328.     }
  329.   }
  331.   // Set up listeners
  332.   var connectHandlers = {
  333.     timeout: connectErrorHandler('timeout'),
  334.     error: connectErrorHandler('error'),
  335.     close: connectErrorHandler('close')
  336.   };
  338.   // Clear out all the current handlers left over
  339.   ["timeout", "error", "close", 'serverOpening', 'serverDescriptionChanged', 'serverHeartbeatStarted',
  340.     'serverHeartbeatSucceeded', 'serverHeartbeatFailed', 'serverClosed', 'topologyOpening',
  341.     'topologyClosed', 'topologyDescriptionChanged'].forEach(function(e) {
  342.     self.s.server.removeAllListeners(e);
  343.   });
  345.   // Add the event handlers
  346.   self.s.server.once('timeout', connectHandlers.timeout);
  347.   self.s.server.once('error', connectHandlers.error);
  348.   self.s.server.once('close', connectHandlers.close);
  349.   self.s.server.once('connect', connectHandler);
  350.   // Reconnect server
  351.   self.s.server.on('reconnect', reconnectHandler);
  352.   self.s.server.on('reconnectFailed', reconnectFailedHandler);
  354.   // Set up SDAM listeners
  355.   self.s.server.on('serverDescriptionChanged', relay('serverDescriptionChanged'));
  356.   self.s.server.on('serverHeartbeatStarted', relay('serverHeartbeatStarted'));
  357.   self.s.server.on('serverHeartbeatSucceeded', relay('serverHeartbeatSucceeded'));
  358.   self.s.server.on('serverHeartbeatFailed', relay('serverHeartbeatFailed'));
  359.   self.s.server.on('serverOpening', relay('serverOpening'));
  360.   self.s.server.on('serverClosed', relay('serverClosed'));
  361.   self.s.server.on('topologyOpening', relay('topologyOpening'));
  362.   self.s.server.on('topologyClosed', relay('topologyClosed'));
  363.   self.s.server.on('topologyDescriptionChanged', relay('topologyDescriptionChanged'));
  364.   self.s.server.on('attemptReconnect', relay('attemptReconnect'));
  365.   self.s.server.on('monitoring', relay('monitoring'));
  367.   // Start connection
  368.   self.s.server.connect(_options);
  369. }
  371. // Server capabilities
  372. Server.prototype.capabilities = function() {
  373.   if(this.s.sCapabilities) return this.s.sCapabilities;
  374.   if(this.s.server.lastIsMaster() == null) return null;
  375.   this.s.sCapabilities = new ServerCapabilities(this.s.server.lastIsMaster());
  376.   return this.s.sCapabilities;
  377. }
  379. define.classMethod('capabilities', {callback: false, promise:false, returns: [ServerCapabilities]});
  381. // Command
  382. Server.prototype.command = function(ns, cmd, options, callback) {
  383.   this.s.server.command(ns, cmd, getReadPreference(options), callback);
  384. }
  386. define.classMethod('command', {callback: true, promise:false});
  388. // Insert
  389. Server.prototype.insert = function(ns, ops, options, callback) {
  390.   this.s.server.insert(ns, ops, options, callback);
  391. }
  393. define.classMethod('insert', {callback: true, promise:false});
  395. // Update
  396. Server.prototype.update = function(ns, ops, options, callback) {
  397.   this.s.server.update(ns, ops, options, callback);
  398. }
  400. define.classMethod('update', {callback: true, promise:false});
  402. // Remove
  403. Server.prototype.remove = function(ns, ops, options, callback) {
  404.   this.s.server.remove(ns, ops, options, callback);
  405. }
  407. define.classMethod('remove', {callback: true, promise:false});
  409. // IsConnected
  410. Server.prototype.isConnected = function() {
  411.   return this.s.server.isConnected();
  412. }
  414. Server.prototype.isDestroyed = function() {
  415.   return this.s.server.isDestroyed();
  416. }
  418. define.classMethod('isConnected', {callback: false, promise:false, returns: [Boolean]});
  420. // Insert
  421. Server.prototype.cursor = function(ns, cmd, options) {
  422.   options.disconnectHandler = this.s.store;
  423.   return this.s.server.cursor(ns, cmd, options);
  424. }
  426. define.classMethod('cursor', {callback: false, promise:false, returns: [Cursor, AggregationCursor, CommandCursor]});
  428. Server.prototype.lastIsMaster = function() {
  429.   return this.s.server.lastIsMaster();
  430. }
  432. /**
  433.  * Unref all sockets
  434.  * @method
  435.  */
  436. Server.prototype.unref = function() {
  437.   this.s.server.unref();
  438. }
  440. Server.prototype.close = function(forceClosed) {
  441.   this.s.server.destroy();
  442.   // We need to wash out all stored processes
  443.   if(forceClosed == true) {
  444.     this.s.storeOptions.force = forceClosed;
  445.     this.s.store.flush();
  446.   }
  447. }
  449. define.classMethod('close', {callback: false, promise:false});
  451. Server.prototype.auth = function() {
  452.   var args = Array.prototype.slice.call(arguments, 0);
  453.   this.s.server.auth.apply(this.s.server, args);
  454. }
  456. define.classMethod('auth', {callback: true, promise:false});
  458. Server.prototype.logout = function() {
  459.   var args = Array.prototype.slice.call(arguments, 0);
  460.   this.s.server.logout.apply(this.s.server, args);
  461. }
  463. define.classMethod('logout', {callback: true, promise:false});
  465. /**
  466.  * All raw connections
  467.  * @method
  468.  * @return {array}
  469.  */
  470. Server.prototype.connections = function() {
  471.   return this.s.server.connections();
  472. }
  474. define.classMethod('connections', {callback: false, promise:false, returns:[Array]});
  476. /**
  477.  * Server connect event
  478.  *
  479.  * @event Server#connect
  480.  * @type {object}
  481.  */
  483. /**
  484.  * Server close event
  485.  *
  486.  * @event Server#close
  487.  * @type {object}
  488.  */
  490. /**
  491.  * Server reconnect event
  492.  *
  493.  * @event Server#reconnect
  494.  * @type {object}
  495.  */
  497. /**
  498.  * Server error event
  499.  *
  500.  * @event Server#error
  501.  * @type {MongoError}
  502.  */
  504. /**
  505.  * Server timeout event
  506.  *
  507.  * @event Server#timeout
  508.  * @type {object}
  509.  */
  511. /**
  512.  * Server parseError event
  513.  *
  514.  * @event Server#parseError
  515.  * @type {object}
  516.  */
  518. module.exports = Server;