mongodb 3.3.3 → 3.4.0

package/lib/core/connection/logger.js

@@ -12,14 +12,19 @@ var pid = process.pid;
 // current logger
 var currentLogger = null;
 
+/**
+ * @callback Logger~loggerCallback
+ * @param {string} msg message being logged
+ * @param {object} state an object containing more metadata about the logging message
+ */
+
 /**
  * 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 {Logger~loggerCallback} [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);
@@ -195,7 +200,7 @@ Logger.reset = function() {
 /**
  * Get the current logger function
  * @method
- * @return {function}
+ * @return {Logger~loggerCallback}
  */
 Logger.currentLogger = function() {
   return currentLogger;
@@ -204,7 +209,7 @@ Logger.currentLogger = function() {
 /**
  * Set the current logger function
  * @method
- * @param {function} logger Logger function.
+ * @param {Logger~loggerCallback} logger Logger function.
  * @return {null}
  */
 Logger.setCurrentLogger = function(logger) {

package/lib/core/connection/msg.js

@@ -59,7 +59,7 @@ class Msg {
     this.options = options || {};
 
     // Additional options
-    this.requestId = Msg.getRequestId();
+    this.requestId = options.requestId ? options.requestId : Msg.getRequestId();
 
     // Serialization option
     this.serializeFunctions =

package/lib/core/connection/pool.js

@@ -20,12 +20,22 @@ const Buffer = require('safe-buffer').Buffer;
 const connect = require('./connect');
 const updateSessionFromResponse = require('../sessions').updateSessionFromResponse;
 const eachAsync = require('../utils').eachAsync;
-
-var DISCONNECTED = 'disconnected';
-var CONNECTING = 'connecting';
-var CONNECTED = 'connected';
-var DESTROYING = 'destroying';
-var DESTROYED = 'destroyed';
+const makeStateMachine = require('../utils').makeStateMachine;
+
+const DISCONNECTED = 'disconnected';
+const CONNECTING = 'connecting';
+const CONNECTED = 'connected';
+const DRAINING = 'draining';
+const DESTROYING = 'destroying';
+const DESTROYED = 'destroyed';
+const stateTransition = makeStateMachine({
+  [DISCONNECTED]: [CONNECTING, DRAINING, DISCONNECTED],
+  [CONNECTING]: [CONNECTING, CONNECTED, DRAINING, DISCONNECTED],
+  [CONNECTED]: [CONNECTED, DISCONNECTED, DRAINING],
+  [DRAINING]: [DRAINING, DESTROYING, DESTROYED],
+  [DESTROYING]: [DESTROYING, DESTROYED],
+  [DESTROYED]: [DESTROYED]
+});
 
 const CONNECTION_EVENTS = new Set([
   'error',
@@ -80,6 +90,14 @@ var Pool = function(topology, options) {
   // Store topology for later use
   this.topology = topology;
 
+  this.s = {
+    state: DISCONNECTED,
+    cancellationToken: new EventEmitter()
+  };
+
+  // we don't care how many connections are listening for cancellation
+  this.s.cancellationToken.setMaxListeners(Infinity);
+
   // Add the options
   this.options = Object.assign(
     {
@@ -138,8 +156,6 @@ var Pool = function(topology, options) {
 
   // Logger instance
   this.logger = Logger('Pool', options);
-  // Pool state
-  this.state = DISCONNECTED;
   // Connections
   this.availableConnections = [];
   this.inUseConnections = [];
@@ -208,6 +224,13 @@ Object.defineProperty(Pool.prototype, 'socketTimeout', {
   }
 });
 
+Object.defineProperty(Pool.prototype, 'state', {
+  enumerable: true,
+  get: function() {
+    return this.s.state;
+  }
+});
+
 // clears all pool state
 function resetPoolState(pool) {
   pool.inUseConnections = [];
@@ -220,47 +243,36 @@ function resetPoolState(pool) {
   pool.reconnectId = null;
 }
 
-function stateTransition(self, newState) {
-  var legalTransitions = {
-    disconnected: [CONNECTING, DESTROYING, DISCONNECTED],
-    connecting: [CONNECTING, DESTROYING, CONNECTED, DISCONNECTED],
-    connected: [CONNECTED, DISCONNECTED, DESTROYING],
-    destroying: [DESTROYING, DESTROYED],
-    destroyed: [DESTROYED]
-  };
-
-  // Get current state
-  var legalStates = legalTransitions[self.state];
-  if (legalStates && legalStates.indexOf(newState) !== -1) {
-    self.emit('stateChanged', self.state, newState);
-    self.state = newState;
-  } else {
-    self.logger.error(
-      f(
-        'Pool with id [%s] failed attempted illegal state transition from [%s] to [%s] only following state allowed [%s]',
-        self.id,
-        self.state,
-        newState,
-        legalStates
-      )
-    );
-  }
-}
-
 function connectionFailureHandler(pool, event, err, conn) {
   if (conn) {
-    if (conn._connectionFailHandled) return;
+    if (conn._connectionFailHandled) {
+      return;
+    }
+
     conn._connectionFailHandled = true;
     conn.destroy();
 
     // Remove the connection
     removeConnection(pool, conn);
 
-    // Flush all work Items on this connection
-    while (conn.workItems.length > 0) {
-      const workItem = conn.workItems.shift();
-      if (workItem.cb) workItem.cb(err);
+    if (
+      pool.state !== DRAINING &&
+      pool.state !== DESTROYED &&
+      pool.options.legacyCompatMode === false
+    ) {
+      // since an error/close/timeout means pool invalidation in a
+      // pre-CMAP world, we will issue a custom `drain` event here to
+      // signal that the server should be recycled
+      stateTransition(pool, DRAINING);
+      pool.emit('drain', err);
+
+      // wait to flush work items so this server isn't selected again immediately
+      process.nextTick(() => conn.flush(err));
+      return;
     }
+
+    // flush remaining work items
+    conn.flush(err);
   }
 
   // Did we catch a timeout, increment the numberOfConsecutiveTimeouts
@@ -280,8 +292,10 @@ function connectionFailureHandler(pool, event, err, conn) {
 
   // No more socket available propegate the event
   if (pool.socketCount() === 0) {
-    if (pool.state !== DESTROYED && pool.state !== DESTROYING) {
-      stateTransition(pool, DISCONNECTED);
+    if (pool.state !== DESTROYED && pool.state !== DESTROYING && pool.state !== DRAINING) {
+      if (pool.options.reconnect) {
+        stateTransition(pool, DISCONNECTED);
+      }
     }
 
     // Do not emit error events, they are always close events
@@ -320,9 +334,7 @@ function attemptReconnect(pool, callback) {
       pool.destroy();
 
       const error = new MongoTimeoutError(
-        `failed to reconnect after ${pool.options.reconnectTries} attempts with interval ${
-          pool.options.reconnectInterval
-        } ms`,
+        `failed to reconnect after ${pool.options.reconnectTries} attempts with interval ${pool.options.reconnectInterval} ms`,
         pool.reconnectError
       );
 
@@ -436,7 +448,7 @@ function messageHandler(self) {
           updateSessionFromResponse(session, document);
         }
 
-        if (document.$clusterTime) {
+        if (self.topology && document.$clusterTime) {
           self.topology.clusterTime = document.$clusterTime;
         }
       }
@@ -547,7 +559,7 @@ Pool.prototype.isDisconnected = function() {
 /**
  * Connect pool
  */
-Pool.prototype.connect = function() {
+Pool.prototype.connect = function(callback) {
   if (this.state !== DISCONNECTED) {
     throw new MongoError('connection in unlawful state ' + this.state);
   }
@@ -555,6 +567,12 @@ Pool.prototype.connect = function() {
   stateTransition(this, CONNECTING);
   createConnection(this, (err, conn) => {
     if (err) {
+      if (typeof callback === 'function') {
+        this.destroy();
+        callback(err);
+        return;
+      }
+
       if (this.state === CONNECTING) {
         this.emit('error', err);
       }
@@ -564,7 +582,6 @@ Pool.prototype.connect = function() {
     }
 
     stateTransition(this, CONNECTED);
-    this.emit('connect', this, conn);
 
     // create min connections
     if (this.minSize) {
@@ -572,6 +589,12 @@ Pool.prototype.connect = function() {
         createConnection(this);
       }
     }
+
+    if (typeof callback === 'function') {
+      callback(null, conn);
+    } else {
+      this.emit('connect', this, conn);
+    }
   });
 };
 
@@ -606,6 +629,11 @@ Pool.prototype.unref = function() {
 
 // Destroy the connections
 function destroy(self, connections, options, callback) {
+  stateTransition(self, DESTROYING);
+
+  // indicate that in-flight connections should cancel
+  self.s.cancellationToken.emit('cancel');
+
   eachAsync(
     connections,
     (conn, cb) => {
@@ -636,14 +664,19 @@ function destroy(self, connections, options, callback) {
  */
 Pool.prototype.destroy = function(force, callback) {
   var self = this;
+  if (typeof force === 'function') {
+    callback = force;
+    force = false;
+  }
+
   // Do not try again if the pool is already dead
   if (this.state === DESTROYED || self.state === DESTROYING) {
     if (typeof callback === 'function') callback(null, null);
     return;
   }
 
-  // Set state to destroyed
-  stateTransition(this, DESTROYING);
+  // Set state to draining
+  stateTransition(this, DRAINING);
 
   // Are we force closing
   if (force) {
@@ -670,6 +703,14 @@ Pool.prototype.destroy = function(force, callback) {
 
   // Wait for the operations to drain before we close the pool
   function checkStatus() {
+    if (self.state === DESTROYED || self.state === DESTROYING) {
+      if (typeof callback === 'function') {
+        callback();
+      }
+
+      return;
+    }
+
     flushMonitoringOperations(self.queue);
 
     if (self.queue.length === 0) {
@@ -686,7 +727,6 @@ Pool.prototype.destroy = function(force, callback) {
       }
 
       destroy(self, connections, { force: false }, callback);
-      // } else if (self.queue.length > 0 && !this.reconnectId) {
     } else {
       // Ensure we empty the queue
       _execute(self)();
@@ -705,6 +745,18 @@ Pool.prototype.destroy = function(force, callback) {
  * @param {function} [callback]
  */
 Pool.prototype.reset = function(callback) {
+  if (this.s.state !== CONNECTED) {
+    if (typeof callback === 'function') {
+      callback(new MongoError('pool is not connected, reset aborted'));
+    }
+
+    return;
+  }
+
+  // signal in-flight connections should be cancelled
+  this.s.cancellationToken.emit('cancel');
+
+  // destroy existing connections
   const connections = this.availableConnections.concat(this.inUseConnections);
   eachAsync(
     connections,
@@ -725,12 +777,12 @@ Pool.prototype.reset = function(callback) {
 
       resetPoolState(this);
 
-      // create an initial connection, and kick off execution again
-      createConnection(this);
-
-      if (typeof callback === 'function') {
-        callback(null, null);
-      }
+      // create a new connection, this will ultimately trigger execution
+      createConnection(this, () => {
+        if (typeof callback === 'function') {
+          callback(null, null);
+        }
+      });
     }
   );
 };
@@ -798,17 +850,12 @@ Pool.prototype.write = function(command, options, cb) {
 
   // Pool was destroyed error out
   if (this.state === DESTROYED || this.state === DESTROYING) {
-    // Callback with an error
-    if (cb) {
-      try {
-        cb(new MongoError('pool destroyed'));
-      } catch (err) {
-        process.nextTick(function() {
-          throw err;
-        });
-      }
-    }
+    cb(new MongoError('pool destroyed'));
+    return;
+  }
 
+  if (this.state === DRAINING) {
+    cb(new MongoError('pool is draining, new operations prohibited'));
     return;
   }
 
@@ -856,10 +903,6 @@ Pool.prototype.write = function(command, options, cb) {
   // Optional per operation socketTimeout
   operation.socketTimeout = options.socketTimeout;
   operation.monitoring = options.monitoring;
-  // Custom socket Timeout
-  if (options.socketTimeout) {
-    operation.socketTimeout = options.socketTimeout;
-  }
 
   // Get the requestId
   operation.requestId = command.requestId;
@@ -922,7 +965,7 @@ Pool.prototype.write = function(command, options, cb) {
 function canCompress(command) {
   const commandDoc = command instanceof Msg ? command.command : command.query;
   const commandName = Object.keys(commandDoc)[0];
-  return uncompressibleCommands.indexOf(commandName) === -1;
+  return !uncompressibleCommands.has(commandName);
 }
 
 // Remove connection method
@@ -950,7 +993,7 @@ function createConnection(pool, callback) {
   }
 
   pool.connectingConnections++;
-  connect(pool.options, (err, connection) => {
+  connect(pool.options, pool.s.cancellationToken, (err, connection) => {
     pool.connectingConnections--;
 
     if (err) {
@@ -958,15 +1001,6 @@ function createConnection(pool, callback) {
         pool.logger.debug(`connection attempt failed with error [${JSON.stringify(err)}]`);
       }
 
-      if (pool.options.legacyCompatMode === false) {
-        // The unified topology uses the reported `error` from a pool to track what error
-        // reason is returned to the user during selection timeout. We only want to emit
-        // this if the pool is active because the listeners are removed on destruction.
-        if (pool.state !== DESTROYED && pool.state !== DESTROYING) {
-          pool.emit('error', err);
-        }
-      }
-
       // check if reconnect is enabled, and attempt retry if so
       if (!pool.reconnectId && pool.options.reconnect) {
         if (pool.state === CONNECTING && pool.options.legacyCompatMode) {
@@ -1057,6 +1091,12 @@ function _execute(self) {
       if (self.availableConnections.length === 0) {
         // Flush any monitoring operations
         flushMonitoringOperations(self.queue);
+
+        // Try to create a new connection to execute stuck operation
+        if (totalConnections < self.options.size && self.queue.length > 0) {
+          createConnection(self);
+        }
+
         break;
       }
 
@@ -1121,10 +1161,7 @@ function _execute(self) {
           }
 
           // Re-execute the operation
-          setTimeout(function() {
-            _execute(self)();
-          }, 10);
-
+          setTimeout(() => _execute(self)(), 10);
           break;
         }
       }

package/lib/core/cursor.js

@@ -435,7 +435,7 @@ class CoreCursor extends Readable {
           return;
         }
 
-        cursor._next(callback);
+        this._initializeCursor(callback);
       });
 
       return;

package/lib/core/error.js

@@ -44,25 +44,29 @@ class MongoError extends Error {
     return new MongoError(options);
   }
 
+  /**
+   * Checks the error to see if it has an error label
+   * @param {string} label The error label to check for
+   * @returns {boolean} returns true if the error has the provided error label
+   */
   hasErrorLabel(label) {
     return this.errorLabels && this.errorLabels.indexOf(label) !== -1;
   }
 }
 
 /**
- * Creates a new MongoNetworkError
+ * An error indicating an issue with the network, including TCP
+ * errors and timeouts.
  *
  * @param {Error|string|object} message The error message
  * @property {string} message The error message
  * @property {string} stack The error call stack
+ * @extends MongoError
  */
 class MongoNetworkError extends MongoError {
   constructor(message) {
     super(message);
     this.name = 'MongoNetworkError';
-
-    // This is added as part of the transactions specification
-    this.errorLabels = ['TransientTransactionError'];
   }
 }
 
@@ -71,6 +75,7 @@ class MongoNetworkError extends MongoError {
  *
  * @param {Error|string|object} message The error message
  * @property {string} message The error message
+ * @extends MongoError
  */
 class MongoParseError extends MongoError {
   constructor(message) {
@@ -80,12 +85,13 @@ class MongoParseError extends MongoError {
 }
 
 /**
- * An error signifying a timeout event
+ * An error signifying a client-side timeout event
  *
  * @param {Error|string|object} message The error message
  * @param {string|object} [reason] The reason the timeout occured
  * @property {string} message The error message
  * @property {string} [reason] An optional reason context for the timeout, generally an error saved during flow of monitoring and selecting servers
+ * @extends MongoError
  */
 class MongoTimeoutError extends MongoError {
   constructor(message, reason) {
@@ -117,6 +123,7 @@ function makeWriteConcernResultObject(input) {
  * @param {object} result The result document (provided if ok: 1)
  * @property {string} message The error message
  * @property {object} [result] The result document (provided if ok: 1)
+ * @extends MongoError
  */
 class MongoWriteConcernError extends MongoError {
   constructor(message, result) {
@@ -147,6 +154,7 @@ const RETRYABLE_ERROR_CODES = new Set([
 /**
  * Determines whether an error is something the driver should attempt to retry
  *
+ * @ignore
  * @param {MongoError|Error} error
  */
 function isRetryableError(error) {
@@ -205,12 +213,15 @@ function isNodeShuttingDownError(err) {
  * then the pool will be cleared, and server state will completely reset
  * locally.
  *
+ * @ignore
  * @see https://github.com/mongodb/specifications/blob/master/source/server-discovery-and-monitoring/server-discovery-and-monitoring.rst#not-master-and-node-is-recovering
  * @param {MongoError|Error} error
  * @param {Server} server
  */
 function isSDAMUnrecoverableError(error, server) {
-  if (error instanceof MongoParseError) {
+  // NOTE: null check is here for a strictly pre-CMAP world, a timeout or
+  //       close event are considered unrecoverable
+  if (error instanceof MongoParseError || error == null) {
     return true;
   }
 

package/lib/core/index.js

@@ -33,7 +33,7 @@ module.exports = {
   Sessions: require('./sessions'),
   BSON: BSON,
   EJSON: EJSON,
-  Topology: require('./sdam/topology'),
+  Topology: require('./sdam/topology').Topology,
   // Raw operations
   Query: require('./connection/commands').Query,
   // Auth mechanisms

package/lib/core/sdam/common.js

@@ -0,0 +1,59 @@
+'use strict';
+
+// shared state names
+const STATE_CLOSING = 'closing';
+const STATE_CLOSED = 'closed';
+const STATE_CONNECTING = 'connecting';
+const STATE_CONNECTED = 'connected';
+
+// An enumeration of topology types we know about
+const TopologyType = {
+  Single: 'Single',
+  ReplicaSetNoPrimary: 'ReplicaSetNoPrimary',
+  ReplicaSetWithPrimary: 'ReplicaSetWithPrimary',
+  Sharded: 'Sharded',
+  Unknown: 'Unknown'
+};
+
+// An enumeration of server types we know about
+const ServerType = {
+  Standalone: 'Standalone',
+  Mongos: 'Mongos',
+  PossiblePrimary: 'PossiblePrimary',
+  RSPrimary: 'RSPrimary',
+  RSSecondary: 'RSSecondary',
+  RSArbiter: 'RSArbiter',
+  RSOther: 'RSOther',
+  RSGhost: 'RSGhost',
+  Unknown: 'Unknown'
+};
+
+const TOPOLOGY_DEFAULTS = {
+  useUnifiedTopology: true,
+  localThresholdMS: 15,
+  serverSelectionTimeoutMS: 30000,
+  heartbeatFrequencyMS: 10000,
+  minHeartbeatFrequencyMS: 500
+};
+
+function drainTimerQueue(queue) {
+  queue.forEach(clearTimeout);
+  queue.clear();
+}
+
+function clearAndRemoveTimerFrom(timer, timers) {
+  clearTimeout(timer);
+  return timers.delete(timer);
+}
+
+module.exports = {
+  STATE_CLOSING,
+  STATE_CLOSED,
+  STATE_CONNECTING,
+  STATE_CONNECTED,
+  TOPOLOGY_DEFAULTS,
+  TopologyType,
+  ServerType,
+  drainTimerQueue,
+  clearAndRemoveTimerFrom
+};

package/lib/core/sdam/monitoring.js

@@ -4,8 +4,8 @@ const ServerDescription = require('./server_description').ServerDescription;
 const calculateDurationInMs = require('../utils').calculateDurationInMs;
 
 // pulled from `Server` implementation
-const STATE_DISCONNECTED = 'disconnected';
-const STATE_DISCONNECTING = 'disconnecting';
+const STATE_CLOSED = 'closed';
+const STATE_CLOSING = 'closing';
 
 /**
  * Published when server description changes, but does NOT include changes to the RTT.
@@ -135,6 +135,14 @@ function monitorServer(server, options) {
     return;
   }
 
+  const rescheduleMonitoring = () => {
+    server.s.monitoring = false;
+    server.s.monitorId = setTimeout(() => {
+      server.s.monitorId = undefined;
+      server.monitor();
+    }, heartbeatFrequencyMS);
+  };
+
   // executes a single check of a server
   const checkServer = callback => {
     let start = process.hrtime();
@@ -164,6 +172,9 @@ function monitorServer(server, options) {
           return callback(err, null);
         }
 
+        // save round trip time
+        server.description.roundTripTime = duration;
+
         const isMaster = result.result;
         server.emit(
           'serverHeartbeatSucceeded',
@@ -176,16 +187,13 @@ function monitorServer(server, options) {
   };
 
   const successHandler = isMaster => {
-    server.s.monitoring = false;
-
     // emit an event indicating that our description has changed
     server.emit('descriptionReceived', new ServerDescription(server.description.address, isMaster));
-    if (server.s.state === STATE_DISCONNECTED || server.s.state === STATE_DISCONNECTING) {
+    if (server.s.state === STATE_CLOSED || server.s.state === STATE_CLOSING) {
       return;
     }
 
-    // schedule the next monitoring process
-    server.s.monitorId = setTimeout(() => monitorServer(server), heartbeatFrequencyMS);
+    rescheduleMonitoring();
   };
 
   // run the actual monitoring loop
@@ -203,15 +211,13 @@ function monitorServer(server, options) {
       // otherwise re-attempt monitoring once
       checkServer((error, isMaster) => {
         if (error) {
-          server.s.monitoring = false;
-
           // we revert to an `Unknown` by emitting a default description with no isMaster
           server.emit(
             'descriptionReceived',
             new ServerDescription(server.description.address, null, { error })
           );
 
-          // we do not reschedule monitoring in this case
+          rescheduleMonitoring();
           return;
         }