mongodb 3.4.0 → 3.5.2

package/lib/cmap/events.js

@@ -0,0 +1,154 @@
+'use strict';
+
+/**
+ * The base class for all monitoring events published from the connection pool
+ *
+ * @property {number} time A timestamp when the event was created
+ * @property {string} address The address (host/port pair) of the pool
+ */
+class ConnectionPoolMonitoringEvent {
+  constructor(pool) {
+    this.time = new Date();
+    this.address = pool.address;
+  }
+}
+
+/**
+ * An event published when a connection pool is created
+ *
+ * @property {Object} options The options used to create this connection pool
+ */
+class ConnectionPoolCreatedEvent extends ConnectionPoolMonitoringEvent {
+  constructor(pool) {
+    super(pool);
+    this.options = pool.options;
+  }
+}
+
+/**
+ * An event published when a connection pool is closed
+ */
+class ConnectionPoolClosedEvent extends ConnectionPoolMonitoringEvent {
+  constructor(pool) {
+    super(pool);
+  }
+}
+
+/**
+ * An event published when a connection pool creates a new connection
+ *
+ * @property {number} connectionId A monotonically increasing, per-pool id for the newly created connection
+ */
+class ConnectionCreatedEvent extends ConnectionPoolMonitoringEvent {
+  constructor(pool, connection) {
+    super(pool);
+    this.connectionId = connection.id;
+  }
+}
+
+/**
+ * An event published when a connection is ready for use
+ *
+ * @property {number} connectionId The id of the connection
+ */
+class ConnectionReadyEvent extends ConnectionPoolMonitoringEvent {
+  constructor(pool, connection) {
+    super(pool);
+    this.connectionId = connection.id;
+  }
+}
+
+/**
+ * An event published when a connection is closed
+ *
+ * @property {number} connectionId The id of the connection
+ * @property {string} reason The reason the connection was closed
+ */
+class ConnectionClosedEvent extends ConnectionPoolMonitoringEvent {
+  constructor(pool, connection, reason) {
+    super(pool);
+    this.connectionId = connection.id;
+    this.reason = reason || 'unknown';
+  }
+}
+
+/**
+ * An event published when a request to check a connection out begins
+ */
+class ConnectionCheckOutStartedEvent extends ConnectionPoolMonitoringEvent {
+  constructor(pool) {
+    super(pool);
+  }
+}
+
+/**
+ * An event published when a request to check a connection out fails
+ *
+ * @property {string} reason The reason the attempt to check out failed
+ */
+class ConnectionCheckOutFailedEvent extends ConnectionPoolMonitoringEvent {
+  constructor(pool, reason) {
+    super(pool);
+    this.reason = reason;
+  }
+}
+
+/**
+ * An event published when a connection is checked out of the connection pool
+ *
+ * @property {number} connectionId The id of the connection
+ */
+class ConnectionCheckedOutEvent extends ConnectionPoolMonitoringEvent {
+  constructor(pool, connection) {
+    super(pool);
+    this.connectionId = connection.id;
+  }
+}
+
+/**
+ * An event published when a connection is checked into the connection pool
+ *
+ * @property {number} connectionId The id of the connection
+ */
+class ConnectionCheckedInEvent extends ConnectionPoolMonitoringEvent {
+  constructor(pool, connection) {
+    super(pool);
+    this.connectionId = connection.id;
+  }
+}
+
+/**
+ * An event published when a connection pool is cleared
+ */
+class ConnectionPoolClearedEvent extends ConnectionPoolMonitoringEvent {
+  constructor(pool) {
+    super(pool);
+  }
+}
+
+const CMAP_EVENT_NAMES = [
+  'connectionPoolCreated',
+  'connectionPoolClosed',
+  'connectionCreated',
+  'connectionReady',
+  'connectionClosed',
+  'connectionCheckOutStarted',
+  'connectionCheckOutFailed',
+  'connectionCheckedOut',
+  'connectionCheckedIn',
+  'connectionPoolCleared'
+];
+
+module.exports = {
+  CMAP_EVENT_NAMES,
+  ConnectionPoolCreatedEvent,
+  ConnectionPoolClosedEvent,
+  ConnectionCreatedEvent,
+  ConnectionReadyEvent,
+  ConnectionClosedEvent,
+  ConnectionCheckOutStartedEvent,
+  ConnectionCheckOutFailedEvent,
+  ConnectionCheckedOutEvent,
+  ConnectionCheckedInEvent,
+  ConnectionPoolClearedEvent
+};

package/lib/{core/cmap → cmap}/message_stream.js

@@ -2,20 +2,20 @@
 
 const Duplex = require('stream').Duplex;
 const BufferList = require('bl');
-const MongoParseError = require('../error').MongoParseError;
-const decompress = require('../wireprotocol/compression').decompress;
-const Response = require('../connection/commands').Response;
-const BinMsg = require('../connection/msg').BinMsg;
-const MongoError = require('../error').MongoError;
-const OP_COMPRESSED = require('../wireprotocol/shared').opcodes.OP_COMPRESSED;
-const OP_MSG = require('../wireprotocol/shared').opcodes.OP_MSG;
-const MESSAGE_HEADER_SIZE = require('../wireprotocol/shared').MESSAGE_HEADER_SIZE;
-const COMPRESSION_DETAILS_SIZE = require('../wireprotocol/shared').COMPRESSION_DETAILS_SIZE;
-const opcodes = require('../wireprotocol/shared').opcodes;
-const compress = require('../wireprotocol/compression').compress;
-const compressorIDs = require('../wireprotocol/compression').compressorIDs;
-const uncompressibleCommands = require('../wireprotocol/compression').uncompressibleCommands;
-const Msg = require('../connection/msg').Msg;
+const MongoParseError = require('../core/error').MongoParseError;
+const decompress = require('../core/wireprotocol/compression').decompress;
+const Response = require('../core/connection/commands').Response;
+const BinMsg = require('../core/connection/msg').BinMsg;
+const MongoError = require('../core/error').MongoError;
+const OP_COMPRESSED = require('../core/wireprotocol/shared').opcodes.OP_COMPRESSED;
+const OP_MSG = require('../core/wireprotocol/shared').opcodes.OP_MSG;
+const MESSAGE_HEADER_SIZE = require('../core/wireprotocol/shared').MESSAGE_HEADER_SIZE;
+const COMPRESSION_DETAILS_SIZE = require('../core/wireprotocol/shared').COMPRESSION_DETAILS_SIZE;
+const opcodes = require('../core/wireprotocol/shared').opcodes;
+const compress = require('../core/wireprotocol/compression').compress;
+const compressorIDs = require('../core/wireprotocol/compression').compressorIDs;
+const uncompressibleCommands = require('../core/wireprotocol/compression').uncompressibleCommands;
+const Msg = require('../core/connection/msg').Msg;
 
 const kDefaultMaxBsonMessageSize = 1024 * 1024 * 16 * 4;
 const kBuffer = Symbol('buffer');
@@ -61,8 +61,9 @@ class MessageStream extends Duplex {
       }
 
       const messageBuffer = buffer.slice(0, sizeOfMessage);
-      processMessage(this, messageBuffer, callback);
       buffer.consume(sizeOfMessage);
+
+      processMessage(this, messageBuffer, callback);
     }
   }
 
@@ -76,7 +77,8 @@ class MessageStream extends Duplex {
     // TODO: agreed compressor should live in `StreamDescription`
     const shouldCompress = operationDescription && !!operationDescription.agreedCompressor;
     if (!shouldCompress || !canCompress(command)) {
-      this.push(Buffer.concat(command.toBin()));
+      const data = command.toBin();
+      this.push(Array.isArray(data) ? Buffer.concat(data) : data);
       return;
     }
 
@@ -125,7 +127,7 @@ function canCompress(command) {
 
 function processMessage(stream, message, callback) {
   const messageHeader = {
-    messageLength: message.readInt32LE(0),
+    length: message.readInt32LE(0),
     requestId: message.readInt32LE(4),
     responseTo: message.readInt32LE(8),
     opCode: message.readInt32LE(12)

package/lib/cmap/stream_description.js

@@ -0,0 +1,45 @@
+'use strict';
+const parseServerType = require('../core/sdam/server_description').parseServerType;
+
+const RESPONSE_FIELDS = [
+  'minWireVersion',
+  'maxWireVersion',
+  'maxBsonObjectSize',
+  'maxMessageSizeBytes',
+  'maxWriteBatchSize',
+  '__nodejs_mock_server__'
+];
+
+class StreamDescription {
+  constructor(address, options) {
+    this.address = address;
+    this.type = parseServerType(null);
+    this.minWireVersion = undefined;
+    this.maxWireVersion = undefined;
+    this.maxBsonObjectSize = 16777216;
+    this.maxMessageSizeBytes = 48000000;
+    this.maxWriteBatchSize = 100000;
+    this.compressors =
+      options && options.compression && Array.isArray(options.compression.compressors)
+        ? options.compression.compressors
+        : [];
+  }
+
+  receiveResponse(response) {
+    this.type = parseServerType(response);
+
+    RESPONSE_FIELDS.forEach(field => {
+      if (typeof response[field] !== 'undefined') {
+        this[field] = response[field];
+      }
+    });
+
+    if (response.compression) {
+      this.compressor = this.compressors.filter(c => response.compression.indexOf(c) !== -1)[0];
+    }
+  }
+}
+
+module.exports = {
+  StreamDescription
+};

package/lib/core/auth/scram.js

@@ -236,7 +236,7 @@ class ScramSHA extends AuthProvider {
       };
 
       sendAuthCommand(connection, `${db}.$cmd`, saslContinueCmd, (err, r) => {
-        if (r && typeof r.ok === 'number' && r.ok === 0) {
+        if (err || (r && typeof r.ok === 'number' && r.ok === 0)) {
           callback(err, r);
           return;
         }

package/lib/core/connection/apm.js

@@ -23,8 +23,9 @@ const namespace = command => command.ns;
 const databaseName = command => command.ns.split('.')[0];
 const collectionName = command => command.ns.split('.')[1];
 const generateConnectionId = pool =>
-  pool.options ? `${pool.options.host}:${pool.options.port}` : pool.id;
+  pool.options ? `${pool.options.host}:${pool.options.port}` : pool.address;
 const maybeRedact = (commandName, result) => (SENSITIVE_COMMANDS.has(commandName) ? {} : result);
+const isLegacyPool = pool => pool.s && pool.queue;
 
 const LEGACY_FIND_QUERY_MAP = {
   $query: 'filter',
@@ -151,6 +152,22 @@ const extractReply = (command, reply) => {
   return reply && reply.result ? reply.result : reply;
 };
 
+const extractConnectionDetails = pool => {
+  if (isLegacyPool(pool)) {
+    return {
+      connectionId: generateConnectionId(pool)
+    };
+  }
+
+  // APM in the modern pool is done at the `Connection` level, so we rename it here for
+  // readability.
+  const connection = pool;
+  return {
+    address: connection.address,
+    connectionId: connection.id
+  };
+};
+
 /** An event indicating the start of a given command */
 class CommandStartedEvent {
   /**
@@ -162,6 +179,7 @@ class CommandStartedEvent {
   constructor(pool, command) {
     const cmd = extractCommand(command);
     const commandName = extractCommandName(cmd);
+    const connectionDetails = extractConnectionDetails(pool);
 
     // NOTE: remove in major revision, this is not spec behavior
     if (SENSITIVE_COMMANDS.has(commandName)) {
@@ -169,8 +187,7 @@ class CommandStartedEvent {
       this.commandObj[commandName] = true;
     }
 
-    Object.assign(this, {
-      connectionId: generateConnectionId(pool),
+    Object.assign(this, connectionDetails, {
       requestId: command.requestId,
       databaseName: databaseName(command),
       commandName,
@@ -192,9 +209,9 @@ class CommandSucceededEvent {
   constructor(pool, command, reply, started) {
     const cmd = extractCommand(command);
     const commandName = extractCommandName(cmd);
+    const connectionDetails = extractConnectionDetails(pool);
 
-    Object.assign(this, {
-      connectionId: generateConnectionId(pool),
+    Object.assign(this, connectionDetails, {
       requestId: command.requestId,
       commandName,
       duration: calculateDurationInMs(started),
@@ -216,9 +233,9 @@ class CommandFailedEvent {
   constructor(pool, command, error, started) {
     const cmd = extractCommand(command);
     const commandName = extractCommandName(cmd);
+    const connectionDetails = extractConnectionDetails(pool);
 
-    Object.assign(this, {
-      connectionId: generateConnectionId(pool),
+    Object.assign(this, connectionDetails, {
       requestId: command.requestId,
       commandName,
       duration: calculateDurationInMs(started),

package/lib/core/connection/connect.js

@@ -3,11 +3,11 @@ const net = require('net');
 const tls = require('tls');
 const Connection = require('./connection');
 const Query = require('./commands').Query;
-const createClientInfo = require('../topologies/shared').createClientInfo;
 const MongoError = require('../error').MongoError;
 const MongoNetworkError = require('../error').MongoNetworkError;
 const defaultAuthProviders = require('../auth/defaultAuthProviders').defaultAuthProviders;
 const WIRE_CONSTANTS = require('../wireprotocol/constants');
+const makeClientMetadata = require('../utils').makeClientMetadata;
 const MAX_SUPPORTED_WIRE_VERSION = WIRE_CONSTANTS.MAX_SUPPORTED_WIRE_VERSION;
 const MAX_SUPPORTED_SERVER_VERSION = WIRE_CONSTANTS.MAX_SUPPORTED_SERVER_VERSION;
 const MIN_SUPPORTED_WIRE_VERSION = WIRE_CONSTANTS.MIN_SUPPORTED_WIRE_VERSION;
@@ -36,6 +36,10 @@ function connect(options, cancellationToken, callback) {
   });
 }
 
+function isModernConnectionType(conn) {
+  return typeof conn.command === 'function';
+}
+
 function getSaslSupportedMechs(options) {
   if (!(options && options.credentials)) {
     return {};
@@ -101,42 +105,51 @@ function performInitialHandshake(conn, options, _callback) {
   const handshakeDoc = Object.assign(
     {
       ismaster: true,
-      client: createClientInfo(options),
+      client: options.metadata || makeClientMetadata(options),
       compression: compressors
     },
     getSaslSupportedMechs(options)
   );
 
+  const handshakeOptions = Object.assign({}, options);
+
+  // The handshake technically is a monitoring check, so its socket timeout should be connectTimeoutMS
+  if (options.connectTimeoutMS || options.connectionTimeout) {
+    handshakeOptions.socketTimeout = options.connectTimeoutMS || options.connectionTimeout;
+  }
+
   const start = new Date().getTime();
-  runCommand(conn, 'admin.$cmd', handshakeDoc, options, (err, ismaster) => {
+  runCommand(conn, 'admin.$cmd', handshakeDoc, handshakeOptions, (err, ismaster) => {
     if (err) {
-      callback(err, null);
+      callback(err);
       return;
     }
 
     if (ismaster.ok === 0) {
-      callback(new MongoError(ismaster), null);
+      callback(new MongoError(ismaster));
       return;
     }
 
     const supportedServerErr = checkSupportedServer(ismaster, options);
     if (supportedServerErr) {
-      callback(supportedServerErr, null);
+      callback(supportedServerErr);
       return;
     }
 
-    // resolve compression
-    if (ismaster.compression) {
-      const agreedCompressors = compressors.filter(
-        compressor => ismaster.compression.indexOf(compressor) !== -1
-      );
+    if (!isModernConnectionType(conn)) {
+      // resolve compression
+      if (ismaster.compression) {
+        const agreedCompressors = compressors.filter(
+          compressor => ismaster.compression.indexOf(compressor) !== -1
+        );
 
-      if (agreedCompressors.length) {
-        conn.agreedCompressor = agreedCompressors[0];
-      }
+        if (agreedCompressors.length) {
+          conn.agreedCompressor = agreedCompressors[0];
+        }
 
-      if (options.compression && options.compression.zlibCompressionLevel) {
-        conn.zlibCompressionLevel = options.compression.zlibCompressionLevel;
+        if (options.compression && options.compression.zlibCompressionLevel) {
+          conn.zlibCompressionLevel = options.compression.zlibCompressionLevel;
+        }
       }
     }
 
@@ -153,7 +166,7 @@ function performInitialHandshake(conn, options, _callback) {
       return;
     }
 
-    callback(null, conn);
+    callback(undefined, conn);
   });
 }
 
@@ -229,7 +242,11 @@ function makeConnection(family, options, cancellationToken, _callback) {
     typeof options.keepAliveInitialDelay === 'number' ? options.keepAliveInitialDelay : 300000;
   const noDelay = typeof options.noDelay === 'boolean' ? options.noDelay : true;
   const connectionTimeout =
-    typeof options.connectionTimeout === 'number' ? options.connectionTimeout : 30000;
+    typeof options.connectionTimeout === 'number'
+      ? options.connectionTimeout
+      : typeof options.connectTimeoutMS === 'number'
+      ? options.connectTimeoutMS
+      : 30000;
   const socketTimeout = typeof options.socketTimeout === 'number' ? options.socketTimeout : 360000;
   const rejectUnauthorized =
     typeof options.rejectUnauthorized === 'boolean' ? options.rejectUnauthorized : true;
@@ -264,6 +281,7 @@ function makeConnection(family, options, cancellationToken, _callback) {
   socket.setTimeout(connectionTimeout);
   socket.setNoDelay(noDelay);
 
+  const connectEvent = useSsl ? 'secureConnect' : 'connect';
   let cancellationHandler;
   function errorHandler(eventName) {
     return err => {
@@ -272,7 +290,7 @@ function makeConnection(family, options, cancellationToken, _callback) {
         cancellationToken.removeListener('cancel', cancellationHandler);
       }
 
-      socket.removeListener('connect', connectHandler);
+      socket.removeListener(connectEvent, connectHandler);
       callback(connectionFailureError(eventName, err));
     };
   }
@@ -297,17 +315,28 @@ function makeConnection(family, options, cancellationToken, _callback) {
     cancellationToken.once('cancel', cancellationHandler);
   }
 
-  socket.once('connect', connectHandler);
+  socket.once(connectEvent, connectHandler);
 }
 
 const CONNECTION_ERROR_EVENTS = ['error', 'close', 'timeout', 'parseError'];
 function runCommand(conn, ns, command, options, callback) {
-  if (typeof conn.command === 'function') {
-    conn.command(ns, command, options, callback);
+  if (typeof options === 'function') (callback = options), (options = {});
+
+  // are we using the new connection type? if so, no need to simulate a rpc `command` method
+  if (isModernConnectionType(conn)) {
+    conn.command(ns, command, options, (err, result) => {
+      if (err) {
+        callback(err);
+        return;
+      }
+
+      // NODE-2382: raw wire protocol messages, or command results should not be used anymore
+      callback(undefined, result.result);
+    });
+
     return;
   }
 
-  if (typeof options === 'function') (callback = options), (options = {});
   const socketTimeout = typeof options.socketTimeout === 'number' ? options.socketTimeout : 360000;
   const bson = conn.options.bson;
   const query = new Query(bson, ns, command, {
@@ -333,7 +362,7 @@ function runCommand(conn, ns, command, options, callback) {
     // ignore all future errors
     conn.on('error', noop);
 
-    _callback(err, null);
+    _callback(err);
   }
 
   function messageHandler(msg) {
@@ -346,7 +375,7 @@ function runCommand(conn, ns, command, options, callback) {
     conn.removeListener('message', messageHandler);
 
     msg.parse({ promoteValues: true });
-    _callback(null, msg.documents[0]);
+    _callback(undefined, msg.documents[0]);
   }
 
   conn.setSocketTimeout(socketTimeout);
@@ -365,7 +394,7 @@ function authenticate(conn, credentials, callback) {
   const provider = AUTH_PROVIDERS[mechanism];
   provider.auth(runCommand, [conn], credentials, err => {
     if (err) return callback(err);
-    callback(null, conn);
+    callback(undefined, conn);
   });
 }
 

package/lib/core/connection/pool.js

@@ -255,22 +255,6 @@ function connectionFailureHandler(pool, event, err, conn) {
     // Remove the connection
     removeConnection(pool, conn);
 
-    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);
   }
@@ -641,6 +625,9 @@ function destroy(self, connections, options, callback) {
         conn.removeAllListeners(eventName);
       }
 
+      // ignore any errors during destruction
+      conn.on('error', () => {});
+
       conn.destroy(options, cb);
     },
     err => {

package/lib/core/error.js

@@ -1,7 +1,6 @@
 'use strict';
 
 const mongoErrorContextSymbol = Symbol('mongoErrorContextSymbol');
-const maxWireVersion = require('./utils').maxWireVersion;
 
 /**
  * Creates a new MongoError
@@ -95,14 +94,35 @@ class MongoParseError extends MongoError {
  */
 class MongoTimeoutError extends MongoError {
   constructor(message, reason) {
-    super(message);
+    if (reason && reason.error) {
+      super(reason.error.message || reason.error);
+    } else {
+      super(message);
+    }
+
     this.name = 'MongoTimeoutError';
-    if (reason != null) {
+    if (reason) {
       this.reason = reason;
     }
   }
 }
 
+/**
+ * An error signifying a client-side server selection error
+ *
+ * @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 MongoServerSelectionError extends MongoTimeoutError {
+  constructor(message, reason) {
+    super(message, reason);
+    this.name = 'MongoServerSelectionError';
+  }
+}
+
 function makeWriteConcernResultObject(input) {
   const output = Object.assign({}, input);
 
@@ -216,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) {
@@ -226,10 +245,6 @@ function isSDAMUnrecoverableError(error, server) {
   }
 
   if (isRecoveringError(error) || isNotMasterError(error)) {
-    if (maxWireVersion(server) >= 8 && !isNodeShuttingDownError(error)) {
-      return false;
-    }
-
     return true;
   }
 
@@ -241,8 +256,10 @@ module.exports = {
   MongoNetworkError,
   MongoParseError,
   MongoTimeoutError,
+  MongoServerSelectionError,
   MongoWriteConcernError,
   mongoErrorContextSymbol,
   isRetryableError,
-  isSDAMUnrecoverableError
+  isSDAMUnrecoverableError,
+  isNodeShuttingDownError
 };

package/lib/core/index.js

@@ -20,6 +20,7 @@ module.exports = {
   MongoNetworkError: require('./error').MongoNetworkError,
   MongoParseError: require('./error').MongoParseError,
   MongoTimeoutError: require('./error').MongoTimeoutError,
+  MongoServerSelectionError: require('./error').MongoServerSelectionError,
   MongoWriteConcernError: require('./error').MongoWriteConcernError,
   mongoErrorContextSymbol: require('./error').mongoErrorContextSymbol,
   // Core