mongodb 3.3.0-beta1 → 3.3.2

package/lib/core/error.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const mongoErrorContextSymbol = Symbol('mongoErrorContextSymbol');
+const maxWireVersion = require('./utils').maxWireVersion;
 
 /**
  * Creates a new MongoError
@@ -152,6 +153,73 @@ function isRetryableError(error) {
   );
 }
 
+const SDAM_RECOVERING_CODES = new Set([
+  91, // ShutdownInProgress
+  189, // PrimarySteppedDown
+  11600, // InterruptedAtShutdown
+  11602, // InterruptedDueToReplStateChange
+  13436 // NotMasterOrSecondary
+]);
+
+const SDAM_NOTMASTER_CODES = new Set([
+  10107, // NotMaster
+  13435 // NotMasterNoSlaveOk
+]);
+
+const SDAM_NODE_SHUTTING_DOWN_ERROR_CODES = new Set([
+  11600, // InterruptedAtShutdown
+  91 // ShutdownInProgress
+]);
+
+function isRecoveringError(err) {
+  if (err.code && SDAM_RECOVERING_CODES.has(err.code)) {
+    return true;
+  }
+
+  return err.message.match(/not master or secondary/) || err.message.match(/node is recovering/);
+}
+
+function isNotMasterError(err) {
+  if (err.code && SDAM_NOTMASTER_CODES.has(err.code)) {
+    return true;
+  }
+
+  if (isRecoveringError(err)) {
+    return false;
+  }
+
+  return err.message.match(/not master/);
+}
+
+function isNodeShuttingDownError(err) {
+  return err.code && SDAM_NODE_SHUTTING_DOWN_ERROR_CODES.has(err.code);
+}
+
+/**
+ * Determines whether SDAM can recover from a given error. If it cannot
+ * then the pool will be cleared, and server state will completely reset
+ * locally.
+ *
+ * @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) {
+    return true;
+  }
+
+  if (isRecoveringError(error) || isNotMasterError(error)) {
+    if (maxWireVersion(server) >= 8 && !isNodeShuttingDownError(error)) {
+      return false;
+    }
+
+    return true;
+  }
+
+  return false;
+}
+
 module.exports = {
   MongoError,
   MongoNetworkError,
@@ -159,5 +227,6 @@ module.exports = {
   MongoTimeoutError,
   MongoWriteConcernError,
   mongoErrorContextSymbol,
-  isRetryableError
+  isRetryableError,
+  isSDAMUnrecoverableError
 };

package/lib/core/index.js

@@ -28,7 +28,7 @@ module.exports = {
   ReplSet: require('./topologies/replset'),
   Mongos: require('./topologies/mongos'),
   Logger: require('./connection/logger'),
-  Cursor: require('./cursor'),
+  Cursor: require('./cursor').CoreCursor,
   ReadPreference: require('./topologies/read_preference'),
   Sessions: require('./sessions'),
   BSON: BSON,

package/lib/core/sdam/server.js

@@ -14,6 +14,7 @@ const MongoParseError = require('../error').MongoParseError;
 const MongoNetworkError = require('../error').MongoNetworkError;
 const collationNotSupported = require('../utils').collationNotSupported;
 const debugOptions = require('../connection/utils').debugOptions;
+const isSDAMUnrecoverableError = require('../error').isSDAMUnrecoverableError;
 
 // Used for filtering out fields for logging
 const DEBUG_FIELDS = [
@@ -95,6 +96,13 @@ class Server extends EventEmitter {
     return this.s.description.address;
   }
 
+  get autoEncrypter() {
+    if (this.s.options && this.s.options.autoEncrypter) {
+      return this.s.options.autoEncrypter;
+    }
+    return null;
+  }
+
   /**
    * Initiate server connect
    */
@@ -154,13 +162,16 @@ class Server extends EventEmitter {
     if (typeof options === 'function') (callback = options), (options = {});
     options = Object.assign({}, { force: false }, options);
 
-    if (!this.s.pool) {
+    const done = err => {
+      this.emit('closed');
       this.s.state = STATE_DISCONNECTED;
       if (typeof callback === 'function') {
-        callback(null, null);
+        callback(err, null);
       }
+    };
 
-      return;
+    if (!this.s.pool) {
+      return done();
     }
 
     ['close', 'error', 'timeout', 'parseError', 'connect'].forEach(event => {
@@ -171,10 +182,7 @@ class Server extends EventEmitter {
       clearTimeout(this.s.monitorId);
     }
 
-    this.s.pool.destroy(options.force, err => {
-      this.s.state = STATE_DISCONNECTED;
-      callback(err);
-    });
+    this.s.pool.destroy(options.force, done);
   }
 
   /**
@@ -231,7 +239,86 @@ class Server extends EventEmitter {
       return;
     }
 
-    wireProtocol.command(this, ns, cmd, options, callback);
+    wireProtocol.command(this, ns, cmd, options, (err, result) => {
+      if (err) {
+        if (options.session && err instanceof MongoNetworkError) {
+          options.session.serverSession.isDirty = true;
+        }
+
+        if (isSDAMUnrecoverableError(err, this)) {
+          this.emit('error', err);
+        }
+      }
+
+      callback(err, result);
+    });
+  }
+
+  /**
+   * Execute a query against the server
+   *
+   * @param {string} ns The MongoDB fully qualified namespace (ex: db1.collection1)
+   * @param {object} cmd The command document for the query
+   * @param {object} options Optional settings
+   * @param {function} callback
+   */
+  query(ns, cmd, cursorState, options, callback) {
+    wireProtocol.query(this, ns, cmd, cursorState, options, (err, result) => {
+      if (err) {
+        if (options.session && err instanceof MongoNetworkError) {
+          options.session.serverSession.isDirty = true;
+        }
+
+        if (isSDAMUnrecoverableError(err, this)) {
+          this.emit('error', err);
+        }
+      }
+
+      callback(err, result);
+    });
+  }
+
+  /**
+   * Execute a `getMore` against the server
+   *
+   * @param {string} ns The MongoDB fully qualified namespace (ex: db1.collection1)
+   * @param {object} cursorState State data associated with the cursor calling this method
+   * @param {object} options Optional settings
+   * @param {function} callback
+   */
+  getMore(ns, cursorState, batchSize, options, callback) {
+    wireProtocol.getMore(this, ns, cursorState, batchSize, options, (err, result) => {
+      if (err) {
+        if (options.session && err instanceof MongoNetworkError) {
+          options.session.serverSession.isDirty = true;
+        }
+
+        if (isSDAMUnrecoverableError(err, this)) {
+          this.emit('error', err);
+        }
+      }
+
+      callback(err, result);
+    });
+  }
+
+  /**
+   * Execute a `killCursors` command against the server
+   *
+   * @param {string} ns The MongoDB fully qualified namespace (ex: db1.collection1)
+   * @param {object} cursorState State data associated with the cursor calling this method
+   * @param {function} callback
+   */
+  killCursors(ns, cursorState, callback) {
+    wireProtocol.killCursors(this, ns, cursorState, (err, result) => {
+      if (err && isSDAMUnrecoverableError(err, this)) {
+        this.emit('error', err);
+      }
+
+      if (typeof callback === 'function') {
+        callback(err, result);
+      }
+    });
   }
 
   /**
@@ -332,11 +419,23 @@ function executeWriteOperation(args, options, callback) {
   }
 
   if (collationNotSupported(server, options)) {
-    callback(new MongoError(`server ${this.name} does not support collation`));
+    callback(new MongoError(`server ${server.name} does not support collation`));
     return;
   }
 
-  return wireProtocol[op](server, ns, ops, options, callback);
+  return wireProtocol[op](server, ns, ops, options, (err, result) => {
+    if (err) {
+      if (options.session && err instanceof MongoNetworkError) {
+        options.session.serverSession.isDirty = true;
+      }
+
+      if (isSDAMUnrecoverableError(err, server)) {
+        server.emit('error', err);
+      }
+    }
+
+    callback(err, result);
+  });
 }
 
 function connectEventHandler(server) {

package/lib/core/sdam/server_description.js

@@ -19,6 +19,13 @@ const WRITABLE_SERVER_TYPES = new Set([
   ServerType.Mongos
 ]);
 
+const DATA_BEARING_SERVER_TYPES = new Set([
+  ServerType.RSPrimary,
+  ServerType.RSSecondary,
+  ServerType.Mongos,
+  ServerType.Standalone
+]);
+
 const ISMASTER_FIELDS = [
   'minWireVersion',
   'maxWireVersion',
@@ -99,6 +106,13 @@ class ServerDescription {
     return this.type === ServerType.RSSecondary || this.isWritable;
   }
 
+  /**
+   * @return {Boolean} Is this server data bearing
+   */
+  get isDataBearing() {
+    return DATA_BEARING_SERVER_TYPES.has(this.type);
+  }
+
   /**
    * @return {Boolean} Is this server available for writes
    */

package/lib/core/sdam/topology.js

@@ -13,17 +13,18 @@ const ReadPreference = require('../topologies/read_preference');
 const readPreferenceServerSelector = require('./server_selectors').readPreferenceServerSelector;
 const writableServerSelector = require('./server_selectors').writableServerSelector;
 const isRetryableWritesSupported = require('../topologies/shared').isRetryableWritesSupported;
-const Cursor = require('../cursor');
+const CoreCursor = require('../cursor').CoreCursor;
 const deprecate = require('util').deprecate;
 const BSON = require('../connection/utils').retrieveBSON();
 const createCompressionInfo = require('../topologies/shared').createCompressionInfo;
 const isRetryableError = require('../error').isRetryableError;
-const MongoParseError = require('../error').MongoParseError;
+const isSDAMUnrecoverableError = require('../error').isSDAMUnrecoverableError;
 const ClientSession = require('../sessions').ClientSession;
 const createClientInfo = require('../topologies/shared').createClientInfo;
 const MongoError = require('../error').MongoError;
 const resolveClusterTime = require('../topologies/shared').resolveClusterTime;
 const SrvPoller = require('./srv_polling').SrvPoller;
+const getMMAPError = require('../topologies/shared').getMMAPError;
 
 // Global state
 let globalTopologyCounter = 0;
@@ -31,8 +32,8 @@ let globalTopologyCounter = 0;
 // Constants
 const TOPOLOGY_DEFAULTS = {
   localThresholdMS: 15,
-  serverSelectionTimeoutMS: 10000,
-  heartbeatFrequencyMS: 30000,
+  serverSelectionTimeoutMS: 30000,
+  heartbeatFrequencyMS: 10000,
   minHeartbeatFrequencyMS: 500
 };
 
@@ -130,7 +131,7 @@ class Topology extends EventEmitter {
       heartbeatFrequencyMS: options.heartbeatFrequencyMS,
       minHeartbeatIntervalMS: options.minHeartbeatIntervalMS,
       // allow users to override the cursor factory
-      Cursor: options.cursorFactory || Cursor,
+      Cursor: options.cursorFactory || CoreCursor,
       // the bson parser
       bson: options.bson || new BSON(),
       // a map of server instances to normalized addresses
@@ -138,7 +139,7 @@ class Topology extends EventEmitter {
       // Server Session Pool
       sessionPool: null,
       // Active client sessions
-      sessions: [],
+      sessions: new Set(),
       // Promise library
       promiseLibrary: options.promiseLibrary || Promise,
       credentials: options.credentials,
@@ -344,8 +345,14 @@ class Topology extends EventEmitter {
       if (typeof selector !== 'function') {
         options = selector;
 
-        translateReadPreference(options);
-        const readPreference = options.readPreference || ReadPreference.primary;
+        let readPreference;
+        if (selector instanceof ReadPreference) {
+          readPreference = selector;
+        } else {
+          translateReadPreference(options);
+          readPreference = options.readPreference || ReadPreference.primary;
+        }
+
         selector = readPreferenceServerSelector(readPreference);
       } else {
         options = {};
@@ -390,6 +397,17 @@ class Topology extends EventEmitter {
   }
 
   // Sessions related methods
+
+  /**
+   * @return Whether the topology should initiate selection to determine session support
+   */
+  shouldCheckForSessionSupport() {
+    return (
+      (this.description.type === TopologyType.Single && !this.description.hasKnownServers) ||
+      !this.description.hasDataBearingServers
+    );
+  }
+
   /**
    * @return Whether sessions are supported on the current topology
    */
@@ -403,10 +421,10 @@ class Topology extends EventEmitter {
   startSession(options, clientOptions) {
     const session = new ClientSession(this, this.s.sessionPool, options, clientOptions);
     session.once('ended', () => {
-      this.s.sessions = this.s.sessions.filter(s => !s.equals(session));
+      this.s.sessions.delete(session);
     });
 
-    this.s.sessions.push(session);
+    this.s.sessions.add(session);
     return session;
   }
 
@@ -632,7 +650,7 @@ class Topology extends EventEmitter {
     const CursorClass = options.cursorFactory || this.s.Cursor;
     translateReadPreference(options);
 
-    return new CursorClass(this.s.bson, ns, cmd, options, topology, this.s.options);
+    return new CursorClass(topology, ns, cmd, options);
   }
 
   get clientInfo() {
@@ -919,7 +937,7 @@ function serverErrorEventHandler(server, topology) {
       new monitoring.ServerClosedEvent(topology.s.id, server.description.address)
     );
 
-    if (err instanceof MongoParseError) {
+    if (isSDAMUnrecoverableError(err, server)) {
       resetServerState(server, err, { clearPool: true });
       return;
     }
@@ -954,6 +972,7 @@ function executeWriteOperation(args, options, callback) {
     const handler = (err, result) => {
       if (!err) return callback(null, result);
       if (!isRetryableError(err)) {
+        err = getMMAPError(err);
         return callback(err);
       }
 
@@ -997,10 +1016,11 @@ function resetServerState(server, error, options) {
       'descriptionReceived',
       new ServerDescription(server.description.address, null, { error })
     );
+    server.monitor();
   }
 
-  if (options.clearPool && server.pool) {
-    server.pool.reset(() => resetState());
+  if (options.clearPool && server.s.pool) {
+    server.s.pool.reset(() => resetState());
     return;
   }
 

package/lib/core/sdam/topology_description.js

@@ -1,7 +1,6 @@
 'use strict';
 const ServerType = require('./server_description').ServerType;
 const ServerDescription = require('./server_description').ServerDescription;
-const ReadPreference = require('../topologies/read_preference');
 const WIRE_CONSTANTS = require('../wireprotocol/constants');
 
 // contstants related to compatability checks
@@ -258,24 +257,17 @@ class TopologyDescription {
   }
 
   /**
-   * Determines if the topology has a readable server available. See the table in the
-   * following section for behaviour rules.
-   *
-   * @param {ReadPreference} [readPreference] An optional read preference for determining if a readable server is present
-   * @return {Boolean} Whether there is a readable server in this topology
+   * Determines if the topology description has any known servers
    */
-  hasReadableServer(/* readPreference */) {
-    // To be implemented when server selection is implemented
+  get hasKnownServers() {
+    return Array.from(this.servers.values()).some(sd => sd.type !== ServerDescription.Unknown);
   }
 
   /**
-   * Determines if the topology has a writable server available. See the table in the
-   * following section for behaviour rules.
-   *
-   * @return {Boolean} Whether there is a writable server in this topology
+   * Determines if this topology description has a data-bearing server available.
    */
-  hasWritableServer() {
-    return this.hasReadableServer(ReadPreference.primary);
+  get hasDataBearingServers() {
+    return Array.from(this.servers.values()).some(sd => sd.isDataBearing);
   }
 
   /**

package/lib/core/sessions.js

@@ -18,7 +18,7 @@ const resolveClusterTime = require('./topologies/shared').resolveClusterTime;
 const isSharded = require('./wireprotocol/shared').isSharded;
 const maxWireVersion = require('./utils').maxWireVersion;
 
-const MAX_FOR_TRANSACTIONS = 7;
+const minWireVersionForShardedTransactions = 8;
 
 function assertAlive(session, callback) {
   if (session.serverSession == null) {
@@ -191,8 +191,9 @@ class ClientSession extends EventEmitter {
 
     const topologyMaxWireVersion = maxWireVersion(this.topology);
     if (
-      isSharded(this.topology) ||
-      (topologyMaxWireVersion != null && topologyMaxWireVersion < MAX_FOR_TRANSACTIONS)
+      isSharded(this.topology) &&
+      topologyMaxWireVersion != null &&
+      topologyMaxWireVersion < minWireVersionForShardedTransactions
     ) {
       throw new MongoError('Transactions are not supported on sharded clusters in MongoDB < 4.2.');
     }
@@ -286,6 +287,7 @@ class ClientSession extends EventEmitter {
 const MAX_WITH_TRANSACTION_TIMEOUT = 120000;
 const UNSATISFIABLE_WRITE_CONCERN_CODE = 100;
 const UNKNOWN_REPL_WRITE_CONCERN_CODE = 79;
+const MAX_TIME_MS_EXPIRED_CODE = 50;
 const NON_DETERMINISTIC_WRITE_CONCERN_ERRORS = new Set([
   'CannotSatisfyWriteConcern',
   'UnknownReplWriteConcern',
@@ -298,15 +300,27 @@ function hasNotTimedOut(startTime, max) {
 
 function isUnknownTransactionCommitResult(err) {
   return (
-    !NON_DETERMINISTIC_WRITE_CONCERN_ERRORS.has(err.codeName) &&
-    err.code !== UNSATISFIABLE_WRITE_CONCERN_CODE &&
-    err.code !== UNKNOWN_REPL_WRITE_CONCERN_CODE
+    isMaxTimeMSExpiredError(err) ||
+    (!NON_DETERMINISTIC_WRITE_CONCERN_ERRORS.has(err.codeName) &&
+      err.code !== UNSATISFIABLE_WRITE_CONCERN_CODE &&
+      err.code !== UNKNOWN_REPL_WRITE_CONCERN_CODE)
+  );
+}
+
+function isMaxTimeMSExpiredError(err) {
+  return (
+    err.code === MAX_TIME_MS_EXPIRED_CODE ||
+    (err.writeConcernError && err.writeConcernError.code === MAX_TIME_MS_EXPIRED_CODE)
   );
 }
 
 function attemptTransactionCommit(session, startTime, fn, options) {
   return session.commitTransaction().catch(err => {
-    if (err instanceof MongoError && hasNotTimedOut(startTime, MAX_WITH_TRANSACTION_TIMEOUT)) {
+    if (
+      err instanceof MongoError &&
+      hasNotTimedOut(startTime, MAX_WITH_TRANSACTION_TIMEOUT) &&
+      !isMaxTimeMSExpiredError(err)
+    ) {
       if (err.hasErrorLabel('UnknownTransactionCommitResult')) {
         return attemptTransactionCommit(session, startTime, fn, options);
       }
@@ -363,6 +377,13 @@ function attemptTransaction(session, startTime, fn, options) {
           return attemptTransaction(session, startTime, fn, options);
         }
 
+        if (isMaxTimeMSExpiredError(err)) {
+          if (err.errorLabels == null) {
+            err.errorLabels = [];
+          }
+          err.errorLabels.push('UnknownTransactionCommitResult');
+        }
+
         throw err;
       }
 
@@ -444,6 +465,10 @@ function endTransaction(session, commandName, callback) {
     Object.assign(command, { writeConcern });
   }
 
+  if (commandName === 'commitTransaction' && session.transaction.options.maxTimeMS) {
+    Object.assign(command, { maxTimeMS: session.transaction.options.maxTimeMS });
+  }
+
   function commandHandler(e, r) {
     if (commandName === 'commitTransaction') {
       session.transaction.transition(TxnState.TRANSACTION_COMMITTED);
@@ -452,7 +477,8 @@ function endTransaction(session, commandName, callback) {
         e &&
         (e instanceof MongoNetworkError ||
           e instanceof MongoWriteConcernError ||
-          isRetryableError(e))
+          isRetryableError(e) ||
+          isMaxTimeMSExpiredError(e))
       ) {
         if (e.errorLabels) {
           const idx = e.errorLabels.indexOf('TransientTransactionError');
@@ -527,6 +553,7 @@ class ServerSession {
     this.id = { id: new Binary(uuidV4(), Binary.SUBTYPE_UUID) };
     this.lastUse = Date.now();
     this.txnNumber = 0;
+    this.isDirty = false;
   }
 
   /**
@@ -603,8 +630,8 @@ class ServerSessionPool {
   release(session) {
     const sessionTimeoutMinutes = this.topology.logicalSessionTimeoutMinutes;
     while (this.sessions.length) {
-      const session = this.sessions[this.sessions.length - 1];
-      if (session.hasTimedOut(sessionTimeoutMinutes)) {
+      const pooledSession = this.sessions[this.sessions.length - 1];
+      if (pooledSession.hasTimedOut(sessionTimeoutMinutes)) {
         this.sessions.pop();
       } else {
         break;
@@ -612,11 +639,38 @@ class ServerSessionPool {
     }
 
     if (!session.hasTimedOut(sessionTimeoutMinutes)) {
+      if (session.isDirty) {
+        return;
+      }
+
+      // otherwise, readd this session to the session pool
       this.sessions.unshift(session);
     }
   }
 }
 
+// TODO: this should be codified in command construction
+// @see https://github.com/mongodb/specifications/blob/master/source/read-write-concern/read-write-concern.rst#read-concern
+function commandSupportsReadConcern(command, options) {
+  if (
+    command.aggregate ||
+    command.count ||
+    command.distinct ||
+    command.find ||
+    command.parallelCollectionScan ||
+    command.geoNear ||
+    command.geoSearch
+  ) {
+    return true;
+  }
+
+  if (command.mapReduce && options.out && (options.out.inline === 1 || options.out === 'inline')) {
+    return true;
+  }
+
+  return false;
+}
+
 /**
  * Optionally decorate a command with sessions specific keys
  *
@@ -640,6 +694,7 @@ function applySession(session, command, options) {
   // first apply non-transaction-specific sessions data
   const inTransaction = session.inTransaction() || isTransactionCommand(command);
   const isRetryableWrite = options.willRetryWrite;
+  const shouldApplyReadConcern = commandSupportsReadConcern(command);
 
   if (serverSession.txnNumber && (isRetryableWrite || inTransaction)) {
     command.txnNumber = BSON.Long.fromNumber(serverSession.txnNumber);
@@ -653,7 +708,7 @@ function applySession(session, command, options) {
 
     // TODO: the following should only be applied to read operation per spec.
     // for causal consistency
-    if (session.supports.causalConsistency && session.operationTime) {
+    if (session.supports.causalConsistency && session.operationTime && shouldApplyReadConcern) {
       command.readConcern = command.readConcern || {};
       Object.assign(command.readConcern, { afterClusterTime: session.operationTime });
     }
@@ -707,5 +762,6 @@ module.exports = {
   ServerSessionPool,
   TxnState,
   applySession,
-  updateSessionFromResponse
+  updateSessionFromResponse,
+  commandSupportsReadConcern
 };