mongodb 3.5.1 → 3.5.2

package/HISTORY.md

@@ -2,6 +2,17 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+<a name="3.5.2"></a>
+## [3.5.2](https://github.com/mongodb/node-mongodb-native/compare/v3.5.1...v3.5.2) (2020-01-20)
+
+
+### Bug Fixes
+
+* properly handle err messages in MongoDB 2.6 servers ([0f4ab38](https://github.com/mongodb/node-mongodb-native/commit/0f4ab38))
+* **topology:** always emit SDAM unrecoverable errors ([57f158f](https://github.com/mongodb/node-mongodb-native/commit/57f158f))
+
+
+
 <a name="3.5.1"></a>
 ## [3.5.1](https://github.com/mongodb/node-mongodb-native/compare/v3.5.0...v3.5.1) (2020-01-17)
 

package/lib/cmap/connection.js

@@ -243,14 +243,16 @@ function messageHandler(conn) {
         conn.emit('clusterTimeReceived', document.$clusterTime);
       }
 
-      if (document.writeConcernError) {
-        callback(new MongoWriteConcernError(document.writeConcernError, document));
-        return;
-      }
+      if (operationDescription.command) {
+        if (document.writeConcernError) {
+          callback(new MongoWriteConcernError(document.writeConcernError, document));
+          return;
+        }
 
-      if (document.ok === 0 || document.$err || document.errmsg) {
-        callback(new MongoError(document));
-        return;
+        if (document.ok === 0 || document.$err || document.errmsg || document.code) {
+          callback(new MongoError(document));
+          return;
+        }
       }
     }
 
@@ -290,6 +292,7 @@ function write(command, options, callback) {
     fullResult: typeof options.fullResult === 'boolean' ? options.fullResult : false,
     noResponse: typeof options.noResponse === 'boolean' ? options.noResponse : false,
     documentsReturnedIn: options.documentsReturnedIn,
+    command: !!options.command,
 
     // for BSON parsing
     promoteLongs: typeof options.promoteLongs === 'boolean' ? options.promoteLongs : true,

package/lib/core/error.js

@@ -1,7 +1,6 @@
 'use strict';
 
 const mongoErrorContextSymbol = Symbol('mongoErrorContextSymbol');
-const maxWireVersion = require('./utils').maxWireVersion;
 
 /**
  * Creates a new MongoError
@@ -237,9 +236,8 @@ function isNodeShuttingDownError(err) {
  * @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) {
+function isSDAMUnrecoverableError(error) {
   // 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) {
@@ -247,10 +245,6 @@ function isSDAMUnrecoverableError(error, server) {
   }
 
   if (isRecoveringError(error) || isNotMasterError(error)) {
-    if (maxWireVersion(server) >= 8 && !isNodeShuttingDownError(error)) {
-      return false;
-    }
-
     return true;
   }
 
@@ -266,5 +260,6 @@ module.exports = {
   MongoWriteConcernError,
   mongoErrorContextSymbol,
   isRetryableError,
-  isSDAMUnrecoverableError
+  isSDAMUnrecoverableError,
+  isNodeShuttingDownError
 };

package/lib/core/sdam/server.js

@@ -286,7 +286,7 @@ class Server extends EventEmitter {
             options.session.serverSession.isDirty = true;
           }
 
-          if (isSDAMUnrecoverableError(err, this)) {
+          if (isSDAMUnrecoverableError(err)) {
             this.emit('error', err);
           }
         }
@@ -319,7 +319,7 @@ class Server extends EventEmitter {
             options.session.serverSession.isDirty = true;
           }
 
-          if (isSDAMUnrecoverableError(err, this)) {
+          if (isSDAMUnrecoverableError(err)) {
             this.emit('error', err);
           }
         }
@@ -352,7 +352,7 @@ class Server extends EventEmitter {
             options.session.serverSession.isDirty = true;
           }
 
-          if (isSDAMUnrecoverableError(err, this)) {
+          if (isSDAMUnrecoverableError(err)) {
             this.emit('error', err);
           }
         }
@@ -382,7 +382,7 @@ class Server extends EventEmitter {
       if (err) return cb(err);
 
       conn.killCursors(ns, cursorState, (err, result) => {
-        if (err && isSDAMUnrecoverableError(err, this)) {
+        if (err && isSDAMUnrecoverableError(err)) {
           this.emit('error', err);
         }
 
@@ -489,7 +489,7 @@ function executeWriteOperation(args, options, callback) {
           options.session.serverSession.isDirty = true;
         }
 
-        if (isSDAMUnrecoverableError(err, server)) {
+        if (isSDAMUnrecoverableError(err)) {
           server.emit('error', err);
         }
       }

package/lib/core/sdam/server_selection.js

@@ -3,12 +3,6 @@ const ServerType = require('./common').ServerType;
 const TopologyType = require('./common').TopologyType;
 const ReadPreference = require('../topologies/read_preference');
 const MongoError = require('../error').MongoError;
-const calculateDurationInMs = require('../utils').calculateDurationInMs;
-const MongoServerSelectionError = require('../error').MongoServerSelectionError;
-
-const common = require('./common');
-const STATE_CLOSED = common.STATE_CLOSED;
-const clearAndRemoveTimerFrom = common.clearAndRemoveTimerFrom;
 
 // max staleness constants
 const IDLE_WRITE_PERIOD = 10000;
@@ -246,90 +240,7 @@ function readPreferenceServerSelector(readPreference) {
   };
 }
 
-/**
- * Selects servers using the provided selector
- *
- * @private
- * @param {Topology} topology The topology to select servers from
- * @param {function} selector The predicate used for selecting servers
- * @param {Number} timeout The max time we are willing wait for selection
- * @param {Number} start A high precision timestamp for the start of the selection process
- * @param {function} callback The callback used to convey errors or the resultant servers
- */
-function selectServers(topology, selector, timeout, start, callback) {
-  const duration = calculateDurationInMs(start);
-  if (duration >= timeout) {
-    return callback(
-      new MongoServerSelectionError(`Server selection timed out after ${timeout} ms`),
-      topology.description
-    );
-  }
-
-  // explicitly disallow selection if client is closed
-  if (topology.s.state === STATE_CLOSED) {
-    callback(new MongoError('Topology is closed, please connect'));
-    return;
-  }
-
-  // otherwise, attempt server selection
-  const serverDescriptions = Array.from(topology.description.servers.values());
-  let descriptions;
-
-  // support server selection by options with readPreference
-  if (typeof selector === 'object') {
-    const readPreference = selector.readPreference
-      ? selector.readPreference
-      : ReadPreference.primary;
-
-    selector = readPreferenceServerSelector(readPreference);
-  }
-
-  try {
-    descriptions = selector
-      ? selector(topology.description, serverDescriptions)
-      : serverDescriptions;
-  } catch (e) {
-    return callback(e, null);
-  }
-
-  if (descriptions.length) {
-    const servers = descriptions.map(description => topology.s.servers.get(description.address));
-    return callback(null, servers);
-  }
-
-  const retrySelection = () => {
-    // ensure all server monitors attempt monitoring soon
-    topology.s.servers.forEach(server => process.nextTick(() => server.requestCheck()));
-
-    const iterationTimer = setTimeout(() => {
-      topology.removeListener('topologyDescriptionChanged', descriptionChangedHandler);
-      callback(
-        new MongoServerSelectionError(
-          `Server selection timed out after ${timeout} ms`,
-          topology.description
-        )
-      );
-    }, timeout - duration);
-
-    const descriptionChangedHandler = () => {
-      // successful iteration, clear the check timer
-      clearAndRemoveTimerFrom(iterationTimer, topology.s.iterationTimers);
-
-      // topology description has changed due to monitoring, reattempt server selection
-      selectServers(topology, selector, timeout, start, callback);
-    };
-
-    // track this timer in case we need to clean it up outside this loop
-    topology.s.iterationTimers.add(iterationTimer);
-
-    topology.once('topologyDescriptionChanged', descriptionChangedHandler);
-  };
-
-  retrySelection();
-}
-
 module.exports = {
-  selectServers,
   writableServerSelector,
   readPreferenceServerSelector
 };

package/lib/core/sdam/topology.js

@@ -1,4 +1,5 @@
 'use strict';
+const Denque = require('denque');
 const EventEmitter = require('events');
 const ServerDescription = require('./server_description').ServerDescription;
 const ServerType = require('./common').ServerType;
@@ -14,9 +15,11 @@ const deprecate = require('util').deprecate;
 const BSON = require('../connection/utils').retrieveBSON();
 const createCompressionInfo = require('../topologies/shared').createCompressionInfo;
 const isRetryableError = require('../error').isRetryableError;
-const isSDAMUnrecoverableError = require('../error').isSDAMUnrecoverableError;
+const isNodeShuttingDownError = require('../error').isNodeShuttingDownError;
+const maxWireVersion = require('../utils').maxWireVersion;
 const ClientSession = require('../sessions').ClientSession;
 const MongoError = require('../error').MongoError;
+const MongoServerSelectionError = require('../error').MongoServerSelectionError;
 const resolveClusterTime = require('../topologies/shared').resolveClusterTime;
 const SrvPoller = require('./srv_polling').SrvPoller;
 const getMMAPError = require('../topologies/shared').getMMAPError;
@@ -34,7 +37,7 @@ const clearAndRemoveTimerFrom = common.clearAndRemoveTimerFrom;
 const serverSelection = require('./server_selection');
 const readPreferenceServerSelector = serverSelection.readPreferenceServerSelector;
 const writableServerSelector = serverSelection.writableServerSelector;
-const selectServers = serverSelection.selectServers;
+// const selectServers = serverSelection.selectServers;
 
 // Global state
 let globalTopologyCounter = 0;
@@ -73,6 +76,9 @@ const DEPRECATED_OPTIONS = new Set([
   'bufferMaxEntries'
 ]);
 
+const kCancelled = Symbol('cancelled');
+const kWaitQueue = Symbol('waitQueue');
+
 /**
  * A container of server instances representing a connection to a MongoDB topology.
  *
@@ -139,6 +145,7 @@ class Topology extends EventEmitter {
       return result;
     }, new Map());
 
+    this[kWaitQueue] = new Denque();
     this.s = {
       // the id of this topology
       id: topologyId,
@@ -194,7 +201,6 @@ class Topology extends EventEmitter {
       clusterTime: null,
 
       // timer management
-      iterationTimers: new Set(),
       connectionTimers: new Set()
     };
 
@@ -334,8 +340,7 @@ class Topology extends EventEmitter {
       return;
     }
 
-    // clear all existing monitor timers
-    drainTimerQueue(this.s.iterationTimers);
+    drainWaitQueue(this[kWaitQueue], new MongoError('Topology closed'));
     drainTimerQueue(this.s.connectionTimers);
 
     if (this.s.srvPoller) {
@@ -415,26 +420,43 @@ class Topology extends EventEmitter {
     const transaction = session && session.transaction;
 
     if (isSharded && transaction && transaction.server) {
-      callback(null, transaction.server);
+      callback(undefined, transaction.server);
       return;
     }
 
-    selectServers(
-      this,
-      selector,
-      options.serverSelectionTimeoutMS,
-      process.hrtime(),
-      (err, servers) => {
-        if (err) return callback(err);
-
-        const selectedServer = randomSelection(servers);
-        if (isSharded && transaction && transaction.isActive) {
-          transaction.pinServer(selectedServer);
-        }
+    // support server selection by options with readPreference
+    let serverSelector = selector;
+    if (typeof selector === 'object') {
+      const readPreference = selector.readPreference
+        ? selector.readPreference
+        : ReadPreference.primary;
 
-        callback(null, selectedServer);
-      }
-    );
+      serverSelector = readPreferenceServerSelector(readPreference);
+    }
+
+    const waitQueueMember = {
+      serverSelector,
+      transaction,
+      callback
+    };
+
+    const serverSelectionTimeoutMS = options.serverSelectionTimeoutMS;
+    if (serverSelectionTimeoutMS) {
+      waitQueueMember.timer = setTimeout(() => {
+        waitQueueMember[kCancelled] = true;
+        waitQueueMember.timer = undefined;
+        const timeoutError = new MongoServerSelectionError(
+          `Server selection timed out after ${serverSelectionTimeoutMS} ms`,
+          this.description
+        );
+
+        waitQueueMember.callback(timeoutError);
+      }, serverSelectionTimeoutMS);
+    }
+
+    // place the member at the front of the wait queue
+    this[kWaitQueue].unshift(waitQueueMember);
+    processWaitQueue(this);
   }
 
   // Sessions related methods
@@ -544,6 +566,11 @@ class Topology extends EventEmitter {
     // update server list from updated descriptions
     updateServers(this, serverDescription);
 
+    // attempt to resolve any outstanding server selection attempts
+    if (this[kWaitQueue].length > 0) {
+      processWaitQueue(this);
+    }
+
     this.emit(
       'topologyDescriptionChanged',
       new events.TopologyDescriptionChangedEvent(
@@ -881,14 +908,12 @@ function serverErrorEventHandler(server, topology) {
       return;
     }
 
-    if (isSDAMUnrecoverableError(err, server)) {
-      // NOTE: this must be commented out until we switch to the new CMAP pool because
-      //       we presently _always_ clear the pool on error.
-      resetServerState(server, err, { clearPool: true });
+    if (maxWireVersion(server) >= 8 && !isNodeShuttingDownError(err)) {
+      resetServerState(server, err);
       return;
     }
 
-    resetServerState(server, err);
+    resetServerState(server, err, { clearPool: true });
   };
 }
 
@@ -1013,6 +1038,64 @@ function srvPollingHandler(topology) {
   };
 }
 
+function drainWaitQueue(queue, err) {
+  while (queue.length) {
+    const waitQueueMember = queue.pop();
+    clearTimeout(waitQueueMember.timer);
+    if (!waitQueueMember[kCancelled]) {
+      waitQueueMember.callback(err);
+    }
+  }
+}
+
+function processWaitQueue(topology) {
+  if (topology.s.state === STATE_CLOSED) {
+    drainWaitQueue(topology[kWaitQueue], new MongoError('Topology is closed, please connect'));
+    return;
+  }
+
+  const isSharded = topology.description.type === TopologyType.Sharded;
+  const serverDescriptions = Array.from(topology.description.servers.values());
+  for (let i = 0; i < topology[kWaitQueue].length; ++i) {
+    const waitQueueMember = topology[kWaitQueue].shift();
+    if (waitQueueMember[kCancelled]) {
+      continue;
+    }
+
+    let selectedDescriptions;
+    try {
+      const serverSelector = waitQueueMember.serverSelector;
+      selectedDescriptions = serverSelector
+        ? serverSelector(topology.description, serverDescriptions)
+        : serverDescriptions;
+    } catch (e) {
+      clearTimeout(waitQueueMember.timer);
+      waitQueueMember.callback(e);
+      break;
+    }
+
+    if (selectedDescriptions.length === 0) {
+      topology[kWaitQueue].push(waitQueueMember);
+      break;
+    }
+
+    const selectedServerDescription = randomSelection(selectedDescriptions);
+    const selectedServer = topology.s.servers.get(selectedServerDescription.address);
+    const transaction = waitQueueMember.transaction;
+    if (isSharded && transaction && transaction.isActive) {
+      transaction.pinServer(selectedServer);
+    }
+
+    clearTimeout(waitQueueMember.timer);
+    waitQueueMember.callback(undefined, selectedServer);
+  }
+
+  if (topology[kWaitQueue].length > 0) {
+    // ensure all server monitors attempt monitoring soon
+    topology.s.servers.forEach(server => process.nextTick(() => server.requestCheck()));
+  }
+}
+
 /**
  * A server opening SDAM monitoring event
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mongodb",
-  "version": "3.5.1",
+  "version": "3.5.2",
   "description": "The official MongoDB driver for Node.js",
   "main": "index.js",
   "files": [