mongodb 3.5.5 → 3.5.9

package/lib/cmap/connection_pool.js

@@ -198,6 +198,10 @@ class ConnectionPool extends EventEmitter {
     return this[kConnections].length;
   }
 
+  get waitQueueSize() {
+    return this[kWaitQueue].length;
+  }
+
   /**
    * Check a connection out of this pool. The connection will continue to be tracked, but no reference to it
    * will be held by the pool. This means that if a connection is checked out it MUST be checked back in or
@@ -295,7 +299,7 @@ class ConnectionPool extends EventEmitter {
     this[kCancellationToken].emit('cancel');
 
     // drain the wait queue
-    while (this[kWaitQueue].length) {
+    while (this.waitQueueSize) {
       const waitQueueMember = this[kWaitQueue].pop();
       clearTimeout(waitQueueMember.timer);
       if (!waitQueueMember[kCancelled]) {
@@ -449,13 +453,17 @@ function processWaitQueue(pool) {
     return;
   }
 
-  while (pool[kWaitQueue].length && pool.availableConnectionCount) {
+  while (pool.waitQueueSize) {
     const waitQueueMember = pool[kWaitQueue].peekFront();
     if (waitQueueMember[kCancelled]) {
       pool[kWaitQueue].shift();
       continue;
     }
 
+    if (!pool.availableConnectionCount) {
+      break;
+    }
+
     const connection = pool[kConnections].shift();
     const isStale = connectionIsStale(pool, connection);
     const isIdle = connectionIsIdle(pool, connection);
@@ -472,7 +480,7 @@ function processWaitQueue(pool) {
   }
 
   const maxPoolSize = pool.options.maxPoolSize;
-  if (pool[kWaitQueue].length && (maxPoolSize <= 0 || pool.totalConnectionCount < maxPoolSize)) {
+  if (pool.waitQueueSize && (maxPoolSize <= 0 || pool.totalConnectionCount < maxPoolSize)) {
     createConnection(pool, (err, connection) => {
       const waitQueueMember = pool[kWaitQueue].shift();
       if (waitQueueMember == null) {

package/lib/collection.js

@@ -310,7 +310,7 @@ const DEPRECATED_FIND_OPTIONS = ['maxScan', 'fields', 'snapshot'];
  * @param {(ReadPreference|string)} [options.readPreference] The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).
  * @param {boolean} [options.partial=false] Specify if the cursor should return partial results when querying against a sharded system
  * @param {number} [options.maxTimeMS] Number of milliseconds to wait before aborting the query.
- * @param {number} [options.maxAwaitTimeMS] The maximum amount of time for the server to wait on new documents to satisfy a tailable cursor query. Requires `taiable` and `awaitData` to be true
+ * @param {number} [options.maxAwaitTimeMS] The maximum amount of time for the server to wait on new documents to satisfy a tailable cursor query. Requires `tailable` and `awaitData` to be true
  * @param {boolean} [options.noCursorTimeout] The server normally times out idle cursors after an inactivity period (10 minutes) to prevent excess memory use. Set this option to prevent that.
  * @param {object} [options.collation] Specify collation (MongoDB 3.4 or higher) settings for update operation (see 3.4 documentation for available fields).
  * @param {ClientSession} [options.session] optional session to use for this operation

package/lib/core/connection/apm.js

@@ -2,7 +2,7 @@
 const Msg = require('../connection/msg').Msg;
 const KillCursor = require('../connection/commands').KillCursor;
 const GetMore = require('../connection/commands').GetMore;
-const calculateDurationInMs = require('../utils').calculateDurationInMs;
+const calculateDurationInMs = require('../../utils').calculateDurationInMs;
 
 /** Commands that we want to redact because of the sensitive nature of their contents */
 const SENSITIVE_COMMANDS = new Set([

package/lib/core/connection/pool.js

@@ -21,6 +21,7 @@ const connect = require('./connect');
 const updateSessionFromResponse = require('../sessions').updateSessionFromResponse;
 const eachAsync = require('../utils').eachAsync;
 const makeStateMachine = require('../utils').makeStateMachine;
+const now = require('../../utils').now;
 
 const DISCONNECTED = 'disconnected';
 const CONNECTING = 'connecting';
@@ -898,7 +899,7 @@ Pool.prototype.write = function(command, options, cb) {
   if (self.options.monitorCommands) {
     this.emit('commandStarted', new apm.CommandStartedEvent(this, command));
 
-    operation.started = process.hrtime();
+    operation.started = now();
     operation.cb = (err, reply) => {
       if (err) {
         self.emit(

package/lib/core/cursor.js

@@ -4,7 +4,6 @@ const Logger = require('./connection/logger');
 const retrieveBSON = require('./connection/utils').retrieveBSON;
 const MongoError = require('./error').MongoError;
 const MongoNetworkError = require('./error').MongoNetworkError;
-const mongoErrorContextSymbol = require('./error').mongoErrorContextSymbol;
 const collationNotSupported = require('./utils').collationNotSupported;
 const ReadPreference = require('./topologies/read_preference');
 const isUnifiedTopology = require('./utils').isUnifiedTopology;
@@ -359,15 +358,6 @@ class CoreCursor extends Readable {
         return this.push(this.cursorState.streamOptions.transform(result));
       }
 
-      // If we provided a map function
-      if (
-        this.cursorState.transforms &&
-        typeof this.cursorState.transforms.doc === 'function' &&
-        result != null
-      ) {
-        return this.push(this.cursorState.transforms.doc(result));
-      }
-
       // Return the result
       this.push(result);
 
@@ -421,7 +411,15 @@ class CoreCursor extends Readable {
       batchSize = this.cursorState.limit - this.cursorState.currentLimit;
     }
 
-    this.server.getMore(this.ns, this.cursorState, batchSize, this.options, callback);
+    const cursorState = this.cursorState;
+    this.server.getMore(this.ns, cursorState, batchSize, this.options, (err, result, conn) => {
+      // NOTE: `getMore` modifies `cursorState`, would be very ideal not to do so in the future
+      if (err || (cursorState.cursorId && cursorState.cursorId.isZero())) {
+        this._endSession();
+      }
+
+      callback(err, result, conn);
+    });
   }
 
   _initializeCursor(callback) {
@@ -442,18 +440,15 @@ class CoreCursor extends Readable {
     }
 
     function done(err, result) {
-      if (
-        cursor.cursorState.cursorId &&
-        cursor.cursorState.cursorId.isZero() &&
-        cursor._endSession
-      ) {
+      const cursorState = cursor.cursorState;
+      if (err || (cursorState.cursorId && cursorState.cursorId.isZero())) {
         cursor._endSession();
       }
 
       if (
-        cursor.cursorState.documents.length === 0 &&
-        cursor.cursorState.cursorId &&
-        cursor.cursorState.cursorId.isZero() &&
+        cursorState.documents.length === 0 &&
+        cursorState.cursorId &&
+        cursorState.cursorId.isZero() &&
         !cursor.cmd.tailable &&
         !cursor.cmd.awaitData
       ) {
@@ -699,8 +694,8 @@ function _setCursorNotifiedImpl(self, callback) {
   self.cursorState.documents = [];
   self.cursorState.cursorIndex = 0;
 
-  if (self._endSession) {
-    self._endSession(undefined, () => callback());
+  if (self.cursorState.session) {
+    self._endSession(callback);
     return;
   }
 
@@ -783,17 +778,9 @@ function nextFunction(self, callback) {
     // Execute the next get more
     self._getMore(function(err, doc, connection) {
       if (err) {
-        if (err instanceof MongoError) {
-          err[mongoErrorContextSymbol].isGetMore = true;
-        }
-
         return handleCallback(callback, err);
       }
 
-      if (self.cursorState.cursorId && self.cursorState.cursorId.isZero() && self._endSession) {
-        self._endSession();
-      }
-
       // Save the returned connection to ensure all getMore's fire over the same connection
       self.connection = connection;
 

package/lib/core/error.js

@@ -1,7 +1,5 @@
 'use strict';
 
-const mongoErrorContextSymbol = Symbol('mongoErrorContextSymbol');
-
 /**
  * Creates a new MongoError
  *
@@ -21,6 +19,10 @@ class MongoError extends Error {
       } else {
         super(message.message || message.errmsg || message.$err || 'n/a');
         for (var name in message) {
+          if (name === 'errmsg') {
+            continue;
+          }
+
           this[name] = message[name];
         }
       }
@@ -29,7 +31,13 @@ class MongoError extends Error {
     }
 
     this.name = 'MongoError';
-    this[mongoErrorContextSymbol] = this[mongoErrorContextSymbol] || {};
+  }
+
+  /**
+   * Legacy name for server error responses
+   */
+  get errmsg() {
+    return this.message;
   }
 
   /**
@@ -262,7 +270,6 @@ module.exports = {
   MongoTimeoutError,
   MongoServerSelectionError,
   MongoWriteConcernError,
-  mongoErrorContextSymbol,
   isRetryableError,
   isSDAMUnrecoverableError,
   isNodeShuttingDownError,

package/lib/core/index.js

@@ -22,7 +22,6 @@ module.exports = {
   MongoTimeoutError: require('./error').MongoTimeoutError,
   MongoServerSelectionError: require('./error').MongoServerSelectionError,
   MongoWriteConcernError: require('./error').MongoWriteConcernError,
-  mongoErrorContextSymbol: require('./error').mongoErrorContextSymbol,
   // Core
   Connection: require('./connection/connection'),
   Server: require('./topologies/server'),

package/lib/core/sdam/monitor.js

@@ -1,13 +1,15 @@
 'use strict';
 
 const ServerType = require('./common').ServerType;
-const calculateDurationInMs = require('../utils').calculateDurationInMs;
 const EventEmitter = require('events');
 const connect = require('../connection/connect');
 const Connection = require('../../cmap/connection').Connection;
 const common = require('./common');
 const makeStateMachine = require('../utils').makeStateMachine;
 const MongoError = require('../error').MongoError;
+const makeInterruptableAsyncInterval = require('../../utils').makeInterruptableAsyncInterval;
+const calculateDurationInMs = require('../../utils').calculateDurationInMs;
+const now = require('../../utils').now;
 
 const sdamEvents = require('./events');
 const ServerHeartbeatStartedEvent = sdamEvents.ServerHeartbeatStartedEvent;
@@ -18,7 +20,6 @@ const kServer = Symbol('server');
 const kMonitorId = Symbol('monitorId');
 const kConnection = Symbol('connection');
 const kCancellationToken = Symbol('cancellationToken');
-const kLastCheckTime = Symbol('lastCheckTime');
 
 const STATE_CLOSED = common.STATE_CLOSED;
 const STATE_CLOSING = common.STATE_CLOSING;
@@ -33,6 +34,10 @@ const stateTransition = makeStateMachine({
 
 const INVALID_REQUEST_CHECK_STATES = new Set([STATE_CLOSING, STATE_CLOSED, STATE_MONITORING]);
 
+function isInCloseState(monitor) {
+  return monitor.s.state === STATE_CLOSED || monitor.s.state === STATE_CLOSING;
+}
+
 class Monitor extends EventEmitter {
   constructor(server, options) {
     super(options);
@@ -41,6 +46,7 @@ class Monitor extends EventEmitter {
     this[kConnection] = undefined;
     this[kCancellationToken] = new EventEmitter();
     this[kCancellationToken].setMaxListeners(Infinity);
+    this[kMonitorId] = null;
     this.s = {
       state: STATE_CLOSED
     };
@@ -89,7 +95,14 @@ class Monitor extends EventEmitter {
       return;
     }
 
-    monitorServer(this);
+    // start
+    const heartbeatFrequencyMS = this.options.heartbeatFrequencyMS;
+    const minHeartbeatFrequencyMS = this.options.minHeartbeatFrequencyMS;
+    this[kMonitorId] = makeInterruptableAsyncInterval(monitorServer(this), {
+      interval: heartbeatFrequencyMS,
+      minInterval: minHeartbeatFrequencyMS,
+      immediate: true
+    });
   }
 
   requestCheck() {
@@ -97,31 +110,19 @@ class Monitor extends EventEmitter {
       return;
     }
 
-    const heartbeatFrequencyMS = this.options.heartbeatFrequencyMS;
-    const minHeartbeatFrequencyMS = this.options.minHeartbeatFrequencyMS;
-    const remainingTime = heartbeatFrequencyMS - calculateDurationInMs(this[kLastCheckTime]);
-    if (remainingTime > minHeartbeatFrequencyMS && this[kMonitorId]) {
-      clearTimeout(this[kMonitorId]);
-      rescheduleMonitoring(this, minHeartbeatFrequencyMS);
-      return;
-    }
-
-    if (this[kMonitorId]) {
-      clearTimeout(this[kMonitorId]);
-    }
-
-    monitorServer(this);
+    this[kMonitorId].wake();
   }
 
   close() {
-    if (this.s.state === STATE_CLOSED || this.s.state === STATE_CLOSING) {
+    if (isInCloseState(this)) {
       return;
     }
 
     stateTransition(this, STATE_CLOSING);
     this[kCancellationToken].emit('cancel');
     if (this[kMonitorId]) {
-      clearTimeout(this[kMonitorId]);
+      this[kMonitorId].stop();
+      this[kMonitorId] = null;
     }
 
     if (this[kConnection]) {
@@ -138,7 +139,7 @@ function checkServer(monitor, callback) {
     monitor[kConnection] = undefined;
   }
 
-  const start = process.hrtime();
+  const start = now();
   monitor.emit('serverHeartbeatStarted', new ServerHeartbeatStartedEvent(monitor.address));
 
   function failureHandler(err) {
@@ -186,7 +187,7 @@ function checkServer(monitor, callback) {
       return;
     }
 
-    if (monitor.s.state === STATE_CLOSING || monitor.s.state === STATE_CLOSED) {
+    if (isInCloseState(monitor)) {
       conn.destroy({ force: true });
       failureHandler(new MongoError('monitor was destroyed'));
       return;
@@ -198,52 +199,44 @@ function checkServer(monitor, callback) {
 }
 
 function monitorServer(monitor) {
-  stateTransition(monitor, STATE_MONITORING);
-
-  // TODO: the next line is a legacy event, remove in v4
-  process.nextTick(() => monitor.emit('monitoring', monitor[kServer]));
+  return callback => {
+    stateTransition(monitor, STATE_MONITORING);
+    function done() {
+      if (!isInCloseState(monitor)) {
+        stateTransition(monitor, STATE_IDLE);
+      }
 
-  checkServer(monitor, e0 => {
-    if (e0 == null) {
-      rescheduleMonitoring(monitor);
-      return;
+      callback();
     }
 
-    // otherwise an error occured on initial discovery, also bail
-    if (monitor[kServer].description.type === ServerType.Unknown) {
-      monitor.emit('resetServer', e0);
-      rescheduleMonitoring(monitor);
-      return;
-    }
+    // TODO: the next line is a legacy event, remove in v4
+    process.nextTick(() => monitor.emit('monitoring', monitor[kServer]));
 
-    // According to the SDAM specification's "Network error during server check" section, if
-    // an ismaster call fails we reset the server's pool. If a server was once connected,
-    // change its type to `Unknown` only after retrying once.
-    monitor.emit('resetConnectionPool');
-
-    checkServer(monitor, e1 => {
-      if (e1) {
-        monitor.emit('resetServer', e1);
+    checkServer(monitor, e0 => {
+      if (e0 == null) {
+        return done();
       }
 
-      rescheduleMonitoring(monitor);
-    });
-  });
-}
+      // otherwise an error occured on initial discovery, also bail
+      if (monitor[kServer].description.type === ServerType.Unknown) {
+        monitor.emit('resetServer', e0);
+        return done();
+      }
 
-function rescheduleMonitoring(monitor, ms) {
-  const heartbeatFrequencyMS = monitor.options.heartbeatFrequencyMS;
-  if (monitor.s.state === STATE_CLOSING || monitor.s.state === STATE_CLOSED) {
-    return;
-  }
+      // According to the SDAM specification's "Network error during server check" section, if
+      // an ismaster call fails we reset the server's pool. If a server was once connected,
+      // change its type to `Unknown` only after retrying once.
+      monitor.emit('resetConnectionPool');
 
-  stateTransition(monitor, STATE_IDLE);
+      checkServer(monitor, e1 => {
+        if (e1) {
+          monitor.emit('resetServer', e1);
+        }
 
-  monitor[kLastCheckTime] = process.hrtime();
-  monitor[kMonitorId] = setTimeout(() => {
-    monitor[kMonitorId] = undefined;
-    monitor.requestCheck();
-  }, ms || heartbeatFrequencyMS);
+        done();
+      });
+    });
+  };
 }
 
 module.exports = {

package/lib/core/sdam/server.js

@@ -415,6 +415,10 @@ Object.defineProperty(Server.prototype, 'clusterTime', {
 });
 
 function calculateRoundTripTime(oldRtt, duration) {
+  if (oldRtt === -1) {
+    return duration;
+  }
+
   const alpha = 0.2;
   return alpha * duration + (1 - alpha) * oldRtt;
 }
@@ -463,11 +467,13 @@ function markServerUnknown(server, error) {
 }
 
 function makeOperationHandler(server, options, callback) {
+  const session = options && options.session;
+
   return function handleOperationResult(err, result) {
     if (err) {
       if (err instanceof MongoNetworkError) {
-        if (options && options.session) {
-          options.session.serverSession.isDirty = true;
+        if (session && !session.hasEnded) {
+          session.serverSession.isDirty = true;
         }
 
         if (!isNetworkTimeoutError(err)) {

package/lib/core/sdam/server_description.js

@@ -4,6 +4,7 @@ const arrayStrictEqual = require('../utils').arrayStrictEqual;
 const tagsStrictEqual = require('../utils').tagsStrictEqual;
 const errorStrictEqual = require('../utils').errorStrictEqual;
 const ServerType = require('./common').ServerType;
+const now = require('../../utils').now;
 
 const WRITABLE_SERVER_TYPES = new Set([
   ServerType.RSPrimary,
@@ -70,7 +71,7 @@ class ServerDescription {
     this.address = address;
     this.error = options.error;
     this.roundTripTime = options.roundTripTime || -1;
-    this.lastUpdateTime = Date.now();
+    this.lastUpdateTime = now();
     this.lastWriteDate = ismaster.lastWrite ? ismaster.lastWrite.lastWriteDate : null;
     this.opTime = ismaster.lastWrite ? ismaster.lastWrite.opTime : null;
     this.type = parseServerType(ismaster);

package/lib/core/sdam/server_selection.js

@@ -48,7 +48,7 @@ function maxStalenessReducer(readPreference, topologyDescription, servers) {
   }
 
   if (topologyDescription.type === TopologyType.ReplicaSetWithPrimary) {
-    const primary = servers.filter(primaryFilter)[0];
+    const primary = Array.from(topologyDescription.servers.values()).filter(primaryFilter)[0];
     return servers.reduce((result, server) => {
       const stalenessMS =
         server.lastUpdateTime -
@@ -60,7 +60,13 @@ function maxStalenessReducer(readPreference, topologyDescription, servers) {
       if (staleness <= readPreference.maxStalenessSeconds) result.push(server);
       return result;
     }, []);
-  } else if (topologyDescription.type === TopologyType.ReplicaSetNoPrimary) {
+  }
+
+  if (topologyDescription.type === TopologyType.ReplicaSetNoPrimary) {
+    if (servers.length === 0) {
+      return servers;
+    }
+
     const sMax = servers.reduce((max, s) => (s.lastWriteDate > max.lastWriteDate ? s : max));
     return servers.reduce((result, server) => {
       const stalenessMS =
@@ -186,6 +192,10 @@ function readPreferenceServerSelector(readPreference) {
       );
     }
 
+    if (topologyDescription.type === TopologyType.Unknown) {
+      return [];
+    }
+
     if (
       topologyDescription.type === TopologyType.Single ||
       topologyDescription.type === TopologyType.Sharded
@@ -193,50 +203,32 @@ function readPreferenceServerSelector(readPreference) {
       return latencyWindowReducer(topologyDescription, servers.filter(knownFilter));
     }
 
-    if (readPreference.mode === ReadPreference.PRIMARY) {
+    const mode = readPreference.mode;
+    if (mode === ReadPreference.PRIMARY) {
       return servers.filter(primaryFilter);
     }
 
-    if (readPreference.mode === ReadPreference.SECONDARY) {
-      return latencyWindowReducer(
-        topologyDescription,
-        tagSetReducer(
-          readPreference,
-          maxStalenessReducer(readPreference, topologyDescription, servers)
-        )
-      ).filter(secondaryFilter);
-    } else if (readPreference.mode === ReadPreference.NEAREST) {
-      return latencyWindowReducer(
-        topologyDescription,
-        tagSetReducer(
-          readPreference,
-          maxStalenessReducer(readPreference, topologyDescription, servers)
-        )
-      ).filter(nearestFilter);
-    } else if (readPreference.mode === ReadPreference.SECONDARY_PREFERRED) {
-      const result = latencyWindowReducer(
-        topologyDescription,
-        tagSetReducer(
-          readPreference,
-          maxStalenessReducer(readPreference, topologyDescription, servers)
-        )
-      ).filter(secondaryFilter);
-
-      return result.length === 0 ? servers.filter(primaryFilter) : result;
-    } else if (readPreference.mode === ReadPreference.PRIMARY_PREFERRED) {
+    if (mode === ReadPreference.PRIMARY_PREFERRED) {
       const result = servers.filter(primaryFilter);
       if (result.length) {
         return result;
       }
+    }
+
+    const filter = mode === ReadPreference.NEAREST ? nearestFilter : secondaryFilter;
+    const selectedServers = latencyWindowReducer(
+      topologyDescription,
+      tagSetReducer(
+        readPreference,
+        maxStalenessReducer(readPreference, topologyDescription, servers.filter(filter))
+      )
+    );
 
-      return latencyWindowReducer(
-        topologyDescription,
-        tagSetReducer(
-          readPreference,
-          maxStalenessReducer(readPreference, topologyDescription, servers)
-        )
-      ).filter(secondaryFilter);
+    if (mode === ReadPreference.SECONDARY_PREFERRED && selectedServers.length === 0) {
+      return servers.filter(primaryFilter);
     }
+
+    return selectedServers;
   };
 }