mongodb 3.3.0-beta1 → 3.3.0-beta2

package/lib/core/cursor.js

@@ -7,7 +7,9 @@ const MongoNetworkError = require('./error').MongoNetworkError;
 const mongoErrorContextSymbol = require('./error').mongoErrorContextSymbol;
 const f = require('util').format;
 const collationNotSupported = require('./utils').collationNotSupported;
-const wireProtocol = require('./wireprotocol');
+const ReadPreference = require('./topologies/read_preference');
+const isUnifiedTopology = require('./utils').isUnifiedTopology;
+
 const BSON = retrieveBSON();
 const Long = BSON.Long;
 
@@ -29,7 +31,7 @@ const Long = BSON.Long;
 /**
  * Creates a new Cursor, not to be used directly
  * @class
- * @param {object} bson An instance of the BSON parser
+ * @param {object} topology The server topology instance.
  * @param {string} ns The MongoDB fully qualified namespace (ex: db1.collection1)
  * @param {{object}|Long} cmd The selector (can be a command or a cursorId)
  * @param {object} [options=null] Optional settings.
@@ -38,14 +40,12 @@ const Long = BSON.Long;
  * @param {object} [options.transforms=null] Transform methods for the cursor results
  * @param {function} [options.transforms.query] Transform the value returned from the initial query
  * @param {function} [options.transforms.doc] Transform each document returned from Cursor.prototype.next
- * @param {object} topology The server topology instance.
- * @param {object} topologyOptions The server topology options.
  * @return {Cursor} A cursor instance
  * @property {number} cursorBatchSize The current cursorBatchSize for the cursor
  * @property {number} cursorLimit The current cursorLimit for the cursor
  * @property {number} cursorSkip The current cursorSkip for the cursor
  */
-var Cursor = function(bson, ns, cmd, options, topology, topologyOptions) {
+var Cursor = function(topology, ns, cmd, options) {
   options = options || {};
 
   // Cursor pool
@@ -57,7 +57,7 @@ var Cursor = function(bson, ns, cmd, options, topology, topologyOptions) {
   this.disconnectHandler = options.disconnectHandler;
 
   // Set local values
-  this.bson = bson;
+  this.bson = topology.s.bson;
   this.ns = ns;
   this.cmd = cmd;
   this.options = options;
@@ -87,6 +87,7 @@ var Cursor = function(bson, ns, cmd, options, topology, topologyOptions) {
   }
 
   // Add promoteLong to cursor state
+  const topologyOptions = topology.s.options;
   if (typeof topologyOptions.promoteLongs === 'boolean') {
     this.cursorState.promoteLongs = topologyOptions.promoteLongs;
   } else if (typeof options.promoteLongs === 'boolean') {
@@ -183,7 +184,7 @@ var handleCallback = function(callback, err, result) {
 };
 
 // Internal methods
-Cursor.prototype._getmore = function(callback) {
+Cursor.prototype._getMore = function(callback) {
   if (this.logger.isDebug())
     this.logger.debug(f('schedule getMore call for query [%s]', JSON.stringify(this.query)));
 
@@ -196,7 +197,7 @@ Cursor.prototype._getmore = function(callback) {
     batchSize = this.cursorState.limit - this.cursorState.currentLimit;
   }
 
-  wireProtocol.getMore(this.server, this.ns, this.cursorState, batchSize, this.options, callback);
+  this.server.getMore(this.ns, this.cursorState, batchSize, this.options, callback);
 };
 
 /**
@@ -305,7 +306,7 @@ Cursor.prototype.kill = function(callback) {
     return;
   }
 
-  wireProtocol.killCursors(this.server, this.ns, this.cursorState, callback);
+  this.server.killCursors(this.ns, this.cursorState, callback);
 };
 
 /**
@@ -406,6 +407,7 @@ var _setCursorNotifiedImpl = function(self, callback) {
   if (self._endSession) {
     return self._endSession(undefined, () => callback());
   }
+
   return callback();
 };
 
@@ -426,7 +428,37 @@ var nextFunction = function(self, callback) {
 
   // We have just started the cursor
   if (!self.cursorState.init) {
-    return initializeCursor(self, callback);
+    // Topology is not connected, save the call in the provided store to be
+    // Executed at some point when the handler deems it's reconnected
+    if (!self.topology.isConnected(self.options)) {
+      // Only need this for single server, because repl sets and mongos
+      // will always continue trying to reconnect
+      if (self.topology._type === 'server' && !self.topology.s.options.reconnect) {
+        // Reconnect is disabled, so we'll never reconnect
+        return callback(new MongoError('no connection available'));
+      }
+
+      if (self.disconnectHandler != null) {
+        if (self.topology.isDestroyed()) {
+          // Topology was destroyed, so don't try to wait for it to reconnect
+          return callback(new MongoError('Topology was destroyed'));
+        }
+
+        self.disconnectHandler.addObjectAndMethod('cursor', self, 'next', [callback], callback);
+        return;
+      }
+    }
+
+    self._initializeCursor((err, result) => {
+      if (err || result === null) {
+        callback(err, result);
+        return;
+      }
+
+      nextFunction(self, callback);
+    });
+
+    return;
   }
 
   if (self.cursorState.limit > 0 && self.cursorState.currentLimit >= self.cursorState.limit) {
@@ -449,11 +481,11 @@ var nextFunction = function(self, callback) {
       );
 
     // Check if connection is dead and return if not possible to
-    // execute a getmore on this connection
+    // execute a getMore on this connection
     if (isConnectionDead(self, callback)) return;
 
     // Execute the next get more
-    self._getmore(function(err, doc, connection) {
+    self._getMore(function(err, doc, connection) {
       if (err) {
         if (err instanceof MongoError) {
           err[mongoErrorContextSymbol].isGetMore = true;
@@ -552,31 +584,21 @@ var nextFunction = function(self, callback) {
   }
 };
 
-function initializeCursor(cursor, callback) {
-  // Topology is not connected, save the call in the provided store to be
-  // Executed at some point when the handler deems it's reconnected
-  if (!cursor.topology.isConnected(cursor.options)) {
-    // Only need this for single server, because repl sets and mongos
-    // will always continue trying to reconnect
-    if (cursor.topology._type === 'server' && !cursor.topology.s.options.reconnect) {
-      // Reconnect is disabled, so we'll never reconnect
-      return callback(new MongoError('no connection available'));
-    }
+Cursor.prototype._initializeCursor = function(callback) {
+  const cursor = this;
 
-    if (cursor.disconnectHandler != null) {
-      if (cursor.topology.isDestroyed()) {
-        // Topology was destroyed, so don't try to wait for it to reconnect
-        return callback(new MongoError('Topology was destroyed'));
+  // NOTE: this goes away once cursors use `executeOperation`
+  if (isUnifiedTopology(cursor.topology) && cursor.topology.shouldCheckForSessionSupport()) {
+    cursor.topology.selectServer(ReadPreference.primaryPreferred, err => {
+      if (err) {
+        callback(err);
+        return;
       }
 
-      return cursor.disconnectHandler.addObjectAndMethod(
-        'cursor',
-        cursor,
-        'next',
-        [callback],
-        callback
-      );
-    }
+      cursor.next(callback);
+    });
+
+    return;
   }
 
   // Very explicitly choose what is passed to selectServer
@@ -604,7 +626,7 @@ function initializeCursor(cursor, callback) {
       return callback(new MongoError(`server ${cursor.server.name} does not support collation`));
     }
 
-    function done() {
+    function done(err, result) {
       if (
         cursor.cursorState.cursorId &&
         cursor.cursorState.cursorId.isZero() &&
@@ -623,7 +645,7 @@ function initializeCursor(cursor, callback) {
         return setCursorNotified(cursor, callback);
       }
 
-      nextFunction(cursor, callback);
+      callback(err, result);
     }
 
     // NOTE: this is a special internal method for cloning a cursor, consider removing
@@ -632,11 +654,13 @@ function initializeCursor(cursor, callback) {
     }
 
     const queryCallback = (err, r) => {
-      if (err) return callback(err);
+      if (err) {
+        return done(err);
+      }
 
       const result = r.message;
       if (result.queryFailure) {
-        return callback(new MongoError(result.documents[0]), null);
+        return done(new MongoError(result.documents[0]), null);
       }
 
       // Check if we have a command cursor
@@ -651,7 +675,7 @@ function initializeCursor(cursor, callback) {
       ) {
         // We have an error document, return the error
         if (result.documents[0]['$err'] || result.documents[0]['errmsg']) {
-          return callback(new MongoError(result.documents[0]), null);
+          return done(new MongoError(result.documents[0]), null);
         }
 
         // We have a cursor document
@@ -665,19 +689,20 @@ function initializeCursor(cursor, callback) {
           cursor.cursorState.cursorId = typeof id === 'number' ? Long.fromNumber(id) : id;
           cursor.cursorState.lastCursorId = cursor.cursorState.cursorId;
           cursor.cursorState.operationTime = result.documents[0].operationTime;
+
           // If we have a firstBatch set it
           if (Array.isArray(result.documents[0].cursor.firstBatch)) {
             cursor.cursorState.documents = result.documents[0].cursor.firstBatch; //.reverse();
           }
 
           // Return after processing command cursor
-          return done(result);
+          return done(null, result);
         }
 
         if (Array.isArray(result.documents[0].result)) {
           cursor.cursorState.documents = result.documents[0].result;
           cursor.cursorState.cursorId = Long.ZERO;
-          return done(result);
+          return done(null, result);
         }
       }
 
@@ -695,8 +720,7 @@ function initializeCursor(cursor, callback) {
         cursor.cursorState.documents = cursor.cursorState.transforms.query(result);
       }
 
-      // Return callback
-      done(result);
+      done(null, result);
     };
 
     if (cursor.logger.isDebug()) {
@@ -708,27 +732,13 @@ function initializeCursor(cursor, callback) {
     }
 
     if (cursor.cmd.find != null) {
-      wireProtocol.query(
-        cursor.server,
-        cursor.ns,
-        cursor.cmd,
-        cursor.cursorState,
-        cursor.options,
-        queryCallback
-      );
-
+      server.query(cursor.ns, cursor.cmd, cursor.cursorState, cursor.options, queryCallback);
       return;
     }
 
-    cursor.query = wireProtocol.command(
-      cursor.server,
-      cursor.ns,
-      cursor.cmd,
-      cursor.options,
-      queryCallback
-    );
+    server.command(cursor.ns, cursor.cmd, cursor.options, queryCallback);
   });
-}
+};
 
 /**
  * Retrieve the next document from the cursor

package/lib/core/error.js

@@ -152,6 +152,28 @@ function isRetryableError(error) {
   );
 }
 
+const SDAM_UNRECOVERABLE_ERROR_CODES = new Set([
+  91, // ShutdownInProgress
+  189, // PrimarySteppedDown
+  10107, // NotMaster
+  11600, // InterruptedAtShutdown
+  11602, // InterruptedDueToReplStateChange
+  13435, // NotMasterNoSlaveOk
+  13436 // NotMasterOrSecondary
+]);
+/**
+ * Determines whether an error is a "node is recovering" error or a "not master" error for SDAM retryability.
+ * 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
+ */
+function isSDAMUnrecoverableError(error) {
+  return (
+    SDAM_UNRECOVERABLE_ERROR_CODES.has(error.code) ||
+    (error.message &&
+      (error.message.match(/not master/) || error.message.match(/node is recovering/)))
+  );
+}
+
 module.exports = {
   MongoError,
   MongoNetworkError,
@@ -159,5 +181,6 @@ module.exports = {
   MongoTimeoutError,
   MongoWriteConcernError,
   mongoErrorContextSymbol,
-  isRetryableError
+  isRetryableError,
+  isSDAMUnrecoverableError
 };

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,68 @@ class Server extends EventEmitter {
       return;
     }
 
-    wireProtocol.command(this, ns, cmd, options, callback);
+    wireProtocol.command(this, ns, cmd, options, (err, result) => {
+      if (err && isSDAMUnrecoverableError(err)) {
+        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 && isSDAMUnrecoverableError(err)) {
+        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 && isSDAMUnrecoverableError(err)) {
+        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.emit('error', err);
+      }
+
+      if (typeof callback === 'function') {
+        callback(err, result);
+      }
+    });
   }
 
   /**
@@ -336,7 +405,13 @@ function executeWriteOperation(args, options, callback) {
     return;
   }
 
-  return wireProtocol[op](server, ns, ops, options, callback);
+  return wireProtocol[op](server, ns, ops, options, (err, result) => {
+    if (err && isSDAMUnrecoverableError(err)) {
+      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

@@ -19,6 +19,7 @@ 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;
@@ -390,6 +391,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
    */
@@ -632,7 +644,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 +931,7 @@ function serverErrorEventHandler(server, topology) {
       new monitoring.ServerClosedEvent(topology.s.id, server.description.address)
     );
 
-    if (err instanceof MongoParseError) {
+    if (err instanceof MongoParseError || isSDAMUnrecoverableError(err)) {
       resetServerState(server, err, { clearPool: true });
       return;
     }
@@ -997,10 +1009,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/topologies/mongos.js

@@ -1110,7 +1110,7 @@ Mongos.prototype.cursor = function(ns, cmd, options) {
   var FinalCursor = options.cursorFactory || this.s.Cursor;
 
   // Return the cursor
-  return new FinalCursor(this.s.bson, ns, cmd, options, topology, this.s.options);
+  return new FinalCursor(topology, ns, cmd, options);
 };
 
 /**

package/lib/core/topologies/replset.js

@@ -1364,7 +1364,7 @@ ReplSet.prototype.cursor = function(ns, cmd, options) {
   var FinalCursor = options.cursorFactory || this.s.Cursor;
 
   // Return the cursor
-  return new FinalCursor(this.s.bson, ns, cmd, options, topology, this.s.options);
+  return new FinalCursor(topology, ns, cmd, options);
 };
 
 /**

package/lib/core/topologies/server.js

@@ -628,6 +628,41 @@ Server.prototype.command = function(ns, cmd, options, callback) {
   wireProtocol.command(self, ns, cmd, options, callback);
 };
 
+/**
+ * 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
+ */
+Server.prototype.query = function(ns, cmd, cursorState, options, callback) {
+  wireProtocol.query(this, ns, cmd, cursorState, options, callback);
+};
+
+/**
+ * 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
+ */
+Server.prototype.getMore = function(ns, cursorState, batchSize, options, callback) {
+  wireProtocol.getMore(this, ns, cursorState, batchSize, options, callback);
+};
+
+/**
+ * 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
+ */
+Server.prototype.killCursors = function(ns, cursorState, callback) {
+  wireProtocol.killCursors(this, ns, cursorState, callback);
+};
+
 /**
  * Insert one or more documents
  * @method
@@ -752,7 +787,7 @@ Server.prototype.cursor = function(ns, cmd, options) {
   var FinalCursor = options.cursorFactory || this.s.Cursor;
 
   // Return the cursor
-  return new FinalCursor(this.s.bson, ns, cmd, options, topology, this.s.options);
+  return new FinalCursor(topology, ns, cmd, options);
 };
 
 /**