mongodb 3.4.0 → 3.5.2

package/HISTORY.md

@@ -2,6 +2,78 @@
 
 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)
+
+
+### Bug Fixes
+
+* **cmap:** accept all node TLS options as pool options ([5995d1d](https://github.com/mongodb/node-mongodb-native/commit/5995d1d))
+* **cmap:** error wait queue members on failed connection creation ([d13b153](https://github.com/mongodb/node-mongodb-native/commit/d13b153))
+* **connect:** listen to `secureConnect` for tls connections ([f8bdb8d](https://github.com/mongodb/node-mongodb-native/commit/f8bdb8d))
+* **transactions:** use options helper to resolve read preference ([9698a76](https://github.com/mongodb/node-mongodb-native/commit/9698a76))
+* **uri_parser:** TLS uri variants imply `ssl=true` ([c8d182e](https://github.com/mongodb/node-mongodb-native/commit/c8d182e))
+
+
+
+<a name="3.5.0"></a>
+# [3.5.0](https://github.com/mongodb/node-mongodb-native/compare/v3.4.1...v3.5.0) (2020-01-14)
+
+
+### Bug Fixes
+
+* copy `ssl` option to pool connection options ([563ced6](https://github.com/mongodb/node-mongodb-native/commit/563ced6))
+* destroy connections marked as closed on checkIn / checkOut ([2bd17a6](https://github.com/mongodb/node-mongodb-native/commit/2bd17a6))
+* ensure sync errors are thrown, and don't callback twice ([cca5b49](https://github.com/mongodb/node-mongodb-native/commit/cca5b49))
+* ignore connection errors during pool destruction ([b8805dc](https://github.com/mongodb/node-mongodb-native/commit/b8805dc))
+* not all message payloads are arrays of Buffer ([e4df5f4](https://github.com/mongodb/node-mongodb-native/commit/e4df5f4))
+* recover on network error during initial connect ([a13dc68](https://github.com/mongodb/node-mongodb-native/commit/a13dc68))
+* remove servers with me mismatch in `updateRsFromPrimary` ([95a772e](https://github.com/mongodb/node-mongodb-native/commit/95a772e))
+* report the correct platform in client metadata ([35d0274](https://github.com/mongodb/node-mongodb-native/commit/35d0274))
+* reschedule monitoring before emitting heartbeat events ([7fcbeb5](https://github.com/mongodb/node-mongodb-native/commit/7fcbeb5))
+* socket timeout for handshake should be `connectTimeoutMS` ([c83af9a](https://github.com/mongodb/node-mongodb-native/commit/c83af9a))
+* timed out streams should be destroyed on `timeout` event ([5319ff9](https://github.com/mongodb/node-mongodb-native/commit/5319ff9))
+* use remote address for stream identifier ([f13c20b](https://github.com/mongodb/node-mongodb-native/commit/f13c20b))
+* used weighted RTT calculation for server selection ([d446be5](https://github.com/mongodb/node-mongodb-native/commit/d446be5))
+* **execute-operation:** don't swallow synchronous errors ([0a2d4e9](https://github.com/mongodb/node-mongodb-native/commit/0a2d4e9))
+* **gridfs:** make a copy of chunk before writing to server ([b4ec5b8](https://github.com/mongodb/node-mongodb-native/commit/b4ec5b8))
+
+
+### Features
+
+* add a `withConnection` helper to the connection pool ([d59dced](https://github.com/mongodb/node-mongodb-native/commit/d59dced))
+* include `connectionId` for APM with new CMAP connection pool ([9bd360c](https://github.com/mongodb/node-mongodb-native/commit/9bd360c))
+* integrate CMAP connection pool into unified topology ([9dd3939](https://github.com/mongodb/node-mongodb-native/commit/9dd3939))
+* introduce `MongoServerSelectionError` ([0cf7ec9](https://github.com/mongodb/node-mongodb-native/commit/0cf7ec9))
+* introduce a class for tracking stream specific attributes ([f6bf82c](https://github.com/mongodb/node-mongodb-native/commit/f6bf82c))
+* introduce a new `Monitor` type for server monitoring ([2bfe2a1](https://github.com/mongodb/node-mongodb-native/commit/2bfe2a1))
+* relay all CMAP events to MongoClient ([1aea4de](https://github.com/mongodb/node-mongodb-native/commit/1aea4de))
+* support socket timeouts on a per-connection level ([93e8ad0](https://github.com/mongodb/node-mongodb-native/commit/93e8ad0))
+
+
+
+<a name="3.4.1"></a>
+## [3.4.1](https://github.com/mongodb/node-mongodb-native/compare/v3.4.0...v3.4.1) (2019-12-19)
+
+
+### Bug Fixes
+
+* **bulk:** use original indexes as map for current op index ([20800ac](https://github.com/mongodb/node-mongodb-native/commit/20800ac))
+* always check for network errors during SCRAM conversation ([e46a70e](https://github.com/mongodb/node-mongodb-native/commit/e46a70e))
+
+
+
 <a name="3.4.0"></a>
 # [3.4.0](https://github.com/mongodb/node-mongodb-native/compare/v3.3.5...v3.4.0) (2019-12-10)
 

package/index.js

@@ -11,6 +11,7 @@ const connect = require('./lib/mongo_client').connect;
 connect.MongoError = core.MongoError;
 connect.MongoNetworkError = core.MongoNetworkError;
 connect.MongoTimeoutError = core.MongoTimeoutError;
+connect.MongoServerSelectionError = core.MongoServerSelectionError;
 connect.MongoParseError = core.MongoParseError;
 connect.MongoWriteConcernError = core.MongoWriteConcernError;
 connect.MongoBulkWriteError = require('./lib/bulk/common').BulkWriteError;

package/lib/bulk/common.js

@@ -475,7 +475,7 @@ function mergeBatchResults(batch, bulkResult, err, result) {
   if (Array.isArray(result.writeErrors)) {
     for (let i = 0; i < result.writeErrors.length; i++) {
       const writeError = {
-        index: batch.originalIndexes[i],
+        index: batch.originalIndexes[result.writeErrors[i].index],
         code: result.writeErrors[i].code,
         errmsg: result.writeErrors[i].errmsg,
         op: batch.operations[result.writeErrors[i].index]

package/lib/cmap/connection.js

@@ -0,0 +1,369 @@
+'use strict';
+
+const EventEmitter = require('events');
+const MessageStream = require('./message_stream');
+const MongoError = require('../core/error').MongoError;
+const MongoNetworkError = require('../core/error').MongoNetworkError;
+const MongoWriteConcernError = require('../core/error').MongoWriteConcernError;
+const CommandResult = require('../core/connection/command_result');
+const StreamDescription = require('./stream_description').StreamDescription;
+const wp = require('../core/wireprotocol');
+const apm = require('../core/connection/apm');
+const updateSessionFromResponse = require('../core/sessions').updateSessionFromResponse;
+const uuidV4 = require('../core/utils').uuidV4;
+
+const kStream = Symbol('stream');
+const kQueue = Symbol('queue');
+const kMessageStream = Symbol('messageStream');
+const kGeneration = Symbol('generation');
+const kLastUseTime = Symbol('lastUseTime');
+const kClusterTime = Symbol('clusterTime');
+const kDescription = Symbol('description');
+const kIsMaster = Symbol('ismaster');
+const kAutoEncrypter = Symbol('autoEncrypter');
+
+class Connection extends EventEmitter {
+  constructor(stream, options) {
+    super(options);
+
+    this.id = options.id;
+    this.address = streamIdentifier(stream);
+    this.bson = options.bson;
+    this.socketTimeout = typeof options.socketTimeout === 'number' ? options.socketTimeout : 360000;
+    this.monitorCommands =
+      typeof options.monitorCommands === 'boolean' ? options.monitorCommands : false;
+    this.closed = false;
+    this.destroyed = false;
+
+    this[kDescription] = new StreamDescription(this.address, options);
+    this[kGeneration] = options.generation;
+    this[kLastUseTime] = Date.now();
+
+    // retain a reference to an `AutoEncrypter` if present
+    if (options.autoEncrypter) {
+      this[kAutoEncrypter] = options.autoEncrypter;
+    }
+
+    // setup parser stream and message handling
+    this[kQueue] = new Map();
+    this[kMessageStream] = new MessageStream(options);
+    this[kMessageStream].on('message', messageHandler(this));
+    this[kStream] = stream;
+    stream.on('error', () => {
+      /* ignore errors, listen to `close` instead */
+    });
+
+    stream.on('close', () => {
+      if (this.closed) {
+        return;
+      }
+
+      this.closed = true;
+      this[kQueue].forEach(op =>
+        op.cb(new MongoNetworkError(`connection ${this.id} to ${this.address} closed`))
+      );
+      this[kQueue].clear();
+
+      this.emit('close');
+    });
+
+    stream.on('timeout', () => {
+      if (this.closed) {
+        return;
+      }
+
+      stream.destroy();
+      this.closed = true;
+      this[kQueue].forEach(op =>
+        op.cb(new MongoNetworkError(`connection ${this.id} to ${this.address} timed out`))
+      );
+      this[kQueue].clear();
+
+      this.emit('close');
+    });
+
+    // hook the message stream up to the passed in stream
+    stream.pipe(this[kMessageStream]);
+    this[kMessageStream].pipe(stream);
+  }
+
+  get description() {
+    return this[kDescription];
+  }
+
+  get ismaster() {
+    return this[kIsMaster];
+  }
+
+  // the `connect` method stores the result of the handshake ismaster on the connection
+  set ismaster(response) {
+    this[kDescription].receiveResponse(response);
+
+    // TODO: remove this, and only use the `StreamDescription` in the future
+    this[kIsMaster] = response;
+  }
+
+  get generation() {
+    return this[kGeneration] || 0;
+  }
+
+  get idleTime() {
+    return Date.now() - this[kLastUseTime];
+  }
+
+  get clusterTime() {
+    return this[kClusterTime];
+  }
+
+  get stream() {
+    return this[kStream];
+  }
+
+  markAvailable() {
+    this[kLastUseTime] = Date.now();
+  }
+
+  destroy(options, callback) {
+    if (typeof options === 'function') {
+      callback = options;
+      options = {};
+    }
+
+    options = Object.assign({ force: false }, options);
+    if (this[kStream] == null || this.destroyed) {
+      this.destroyed = true;
+      if (typeof callback === 'function') {
+        callback();
+      }
+
+      return;
+    }
+
+    if (options.force) {
+      this[kStream].destroy();
+      this.destroyed = true;
+      if (typeof callback === 'function') {
+        callback();
+      }
+
+      return;
+    }
+
+    this[kStream].end(err => {
+      this.destroyed = true;
+      if (typeof callback === 'function') {
+        callback(err);
+      }
+    });
+  }
+
+  // Wire protocol methods
+  command(ns, cmd, options, callback) {
+    wp.command(makeServerTrampoline(this), ns, cmd, options, callback);
+  }
+
+  query(ns, cmd, cursorState, options, callback) {
+    wp.query(makeServerTrampoline(this), ns, cmd, cursorState, options, callback);
+  }
+
+  getMore(ns, cursorState, batchSize, options, callback) {
+    wp.getMore(makeServerTrampoline(this), ns, cursorState, batchSize, options, callback);
+  }
+
+  killCursors(ns, cursorState, callback) {
+    wp.killCursors(makeServerTrampoline(this), ns, cursorState, callback);
+  }
+
+  insert(ns, ops, options, callback) {
+    wp.insert(makeServerTrampoline(this), ns, ops, options, callback);
+  }
+
+  update(ns, ops, options, callback) {
+    wp.update(makeServerTrampoline(this), ns, ops, options, callback);
+  }
+
+  remove(ns, ops, options, callback) {
+    wp.remove(makeServerTrampoline(this), ns, ops, options, callback);
+  }
+}
+
+/// This lets us emulate a legacy `Server` instance so we can work with the existing wire
+/// protocol methods. Eventually, the operation executor will return a `Connection` to execute
+/// against.
+function makeServerTrampoline(connection) {
+  const server = {
+    description: connection.description,
+    clusterTime: connection[kClusterTime],
+    s: {
+      bson: connection.bson,
+      pool: { write: write.bind(connection), isConnected: () => true }
+    }
+  };
+
+  if (connection[kAutoEncrypter]) {
+    server.autoEncrypter = connection[kAutoEncrypter];
+  }
+
+  return server;
+}
+
+function messageHandler(conn) {
+  return function messageHandler(message) {
+    // always emit the message, in case we are streaming
+    conn.emit('message', message);
+    if (!conn[kQueue].has(message.responseTo)) {
+      return;
+    }
+
+    const operationDescription = conn[kQueue].get(message.responseTo);
+    conn[kQueue].delete(message.responseTo);
+
+    const callback = operationDescription.cb;
+    if (operationDescription.socketTimeoutOverride) {
+      conn[kStream].setTimeout(conn.socketTimeout);
+    }
+
+    try {
+      // Pass in the entire description because it has BSON parsing options
+      message.parse(operationDescription);
+    } catch (err) {
+      callback(new MongoError(err));
+      return;
+    }
+
+    if (message.documents[0]) {
+      const document = message.documents[0];
+      const session = operationDescription.session;
+      if (session) {
+        updateSessionFromResponse(session, document);
+      }
+
+      if (document.$clusterTime) {
+        conn[kClusterTime] = document.$clusterTime;
+        conn.emit('clusterTimeReceived', document.$clusterTime);
+      }
+
+      if (operationDescription.command) {
+        if (document.writeConcernError) {
+          callback(new MongoWriteConcernError(document.writeConcernError, document));
+          return;
+        }
+
+        if (document.ok === 0 || document.$err || document.errmsg || document.code) {
+          callback(new MongoError(document));
+          return;
+        }
+      }
+    }
+
+    // NODE-2382: reenable in our glorious non-leaky abstraction future
+    // callback(null, operationDescription.fullResult ? message : message.documents[0]);
+
+    callback(
+      undefined,
+      new CommandResult(
+        operationDescription.fullResult ? message : message.documents[0],
+        conn,
+        message
+      )
+    );
+  };
+}
+
+function streamIdentifier(stream) {
+  if (typeof stream.address === 'function') {
+    return `${stream.remoteAddress}:${stream.remotePort}`;
+  }
+
+  return uuidV4().toString('hex');
+}
+
+// Not meant to be called directly, the wire protocol methods call this assuming it is a `Pool` instance
+function write(command, options, callback) {
+  if (typeof options === 'function') {
+    callback = options;
+  }
+
+  options = options || {};
+  const operationDescription = {
+    requestId: command.requestId,
+    cb: callback,
+    session: options.session,
+    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,
+    promoteValues: typeof options.promoteValues === 'boolean' ? options.promoteValues : true,
+    promoteBuffers: typeof options.promoteBuffers === 'boolean' ? options.promoteBuffers : false,
+    raw: typeof options.raw === 'boolean' ? options.raw : false
+  };
+
+  if (this[kDescription] && this[kDescription].compressor) {
+    operationDescription.agreedCompressor = this[kDescription].compressor;
+
+    if (this[kDescription].zlibCompressionLevel) {
+      operationDescription.zlibCompressionLevel = this[kDescription].zlibCompressionLevel;
+    }
+  }
+
+  if (typeof options.socketTimeout === 'number') {
+    operationDescription.socketTimeoutOverride = true;
+    this[kStream].setTimeout(options.socketTimeout);
+  }
+
+  // if command monitoring is enabled we need to modify the callback here
+  if (this.monitorCommands) {
+    this.emit('commandStarted', new apm.CommandStartedEvent(this, command));
+
+    operationDescription.started = process.hrtime();
+    operationDescription.cb = (err, reply) => {
+      if (err) {
+        this.emit(
+          'commandFailed',
+          new apm.CommandFailedEvent(this, command, err, operationDescription.started)
+        );
+      } else {
+        if (reply && reply.result && (reply.result.ok === 0 || reply.result.$err)) {
+          this.emit(
+            'commandFailed',
+            new apm.CommandFailedEvent(this, command, reply.result, operationDescription.started)
+          );
+        } else {
+          this.emit(
+            'commandSucceeded',
+            new apm.CommandSucceededEvent(this, command, reply, operationDescription.started)
+          );
+        }
+      }
+
+      if (typeof callback === 'function') {
+        callback(err, reply);
+      }
+    };
+  }
+
+  if (!operationDescription.noResponse) {
+    this[kQueue].set(operationDescription.requestId, operationDescription);
+  }
+
+  try {
+    this[kMessageStream].writeCommand(command, operationDescription);
+  } catch (e) {
+    if (!operationDescription.noResponse) {
+      this[kQueue].delete(operationDescription.requestId);
+      operationDescription.cb(e);
+      return;
+    }
+  }
+
+  if (operationDescription.noResponse) {
+    operationDescription.cb();
+  }
+}
+
+module.exports = {
+  Connection
+};