mongodb 3.2.5 → 3.3.0-beta2

package/lib/core/error.js

@@ -0,0 +1,186 @@
+'use strict';
+
+const mongoErrorContextSymbol = Symbol('mongoErrorContextSymbol');
+
+/**
+ * Creates a new MongoError
+ *
+ * @augments Error
+ * @param {Error|string|object} message The error message
+ * @property {string} message The error message
+ * @property {string} stack The error call stack
+ */
+class MongoError extends Error {
+  constructor(message) {
+    if (message instanceof Error) {
+      super(message.message);
+      this.stack = message.stack;
+    } else {
+      if (typeof message === 'string') {
+        super(message);
+      } else {
+        super(message.message || message.errmsg || message.$err || 'n/a');
+        for (var name in message) {
+          this[name] = message[name];
+        }
+      }
+
+      Error.captureStackTrace(this, this.constructor);
+    }
+
+    this.name = 'MongoError';
+    this[mongoErrorContextSymbol] = this[mongoErrorContextSymbol] || {};
+  }
+
+  /**
+   * Creates a new MongoError object
+   *
+   * @param {Error|string|object} options The options used to create the error.
+   * @return {MongoError} A MongoError instance
+   * @deprecated Use `new MongoError()` instead.
+   */
+  static create(options) {
+    return new MongoError(options);
+  }
+
+  hasErrorLabel(label) {
+    return this.errorLabels && this.errorLabels.indexOf(label) !== -1;
+  }
+}
+
+/**
+ * Creates a new MongoNetworkError
+ *
+ * @param {Error|string|object} message The error message
+ * @property {string} message The error message
+ * @property {string} stack The error call stack
+ */
+class MongoNetworkError extends MongoError {
+  constructor(message) {
+    super(message);
+    this.name = 'MongoNetworkError';
+
+    // This is added as part of the transactions specification
+    this.errorLabels = ['TransientTransactionError'];
+  }
+}
+
+/**
+ * An error used when attempting to parse a value (like a connection string)
+ *
+ * @param {Error|string|object} message The error message
+ * @property {string} message The error message
+ */
+class MongoParseError extends MongoError {
+  constructor(message) {
+    super(message);
+    this.name = 'MongoParseError';
+  }
+}
+
+/**
+ * An error signifying a timeout event
+ *
+ * @param {Error|string|object} message The error message
+ * @property {string} message The error message
+ */
+class MongoTimeoutError extends MongoError {
+  constructor(message) {
+    super(message);
+    this.name = 'MongoTimeoutError';
+  }
+}
+
+function makeWriteConcernResultObject(input) {
+  const output = Object.assign({}, input);
+
+  if (output.ok === 0) {
+    output.ok = 1;
+    delete output.errmsg;
+    delete output.code;
+    delete output.codeName;
+  }
+
+  return output;
+}
+
+/**
+ * An error thrown when the server reports a writeConcernError
+ *
+ * @param {Error|string|object} message The error message
+ * @param {object} result The result document (provided if ok: 1)
+ * @property {string} message The error message
+ * @property {object} [result] The result document (provided if ok: 1)
+ */
+class MongoWriteConcernError extends MongoError {
+  constructor(message, result) {
+    super(message);
+    this.name = 'MongoWriteConcernError';
+
+    if (result != null) {
+      this.result = makeWriteConcernResultObject(result);
+    }
+  }
+}
+
+// see: https://github.com/mongodb/specifications/blob/master/source/retryable-writes/retryable-writes.rst#terms
+const RETRYABLE_ERROR_CODES = new Set([
+  6, // HostUnreachable
+  7, // HostNotFound
+  89, // NetworkTimeout
+  91, // ShutdownInProgress
+  189, // PrimarySteppedDown
+  9001, // SocketException
+  10107, // NotMaster
+  11600, // InterruptedAtShutdown
+  11602, // InterruptedDueToReplStateChange
+  13435, // NotMasterNoSlaveOk
+  13436 // NotMasterOrSecondary
+]);
+
+/**
+ * Determines whether an error is something the driver should attempt to retry
+ *
+ * @param {MongoError|Error} error
+ */
+function isRetryableError(error) {
+  return (
+    RETRYABLE_ERROR_CODES.has(error.code) ||
+    error instanceof MongoNetworkError ||
+    error.message.match(/not master/) ||
+    error.message.match(/node is recovering/)
+  );
+}
+
+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,
+  MongoParseError,
+  MongoTimeoutError,
+  MongoWriteConcernError,
+  mongoErrorContextSymbol,
+  isRetryableError,
+  isSDAMUnrecoverableError
+};

package/lib/core/index.js

@@ -0,0 +1,50 @@
+'use strict';
+
+let BSON = require('bson');
+const require_optional = require('require_optional');
+const EJSON = require('./utils').retrieveEJSON();
+
+try {
+  // Attempt to grab the native BSON parser
+  const BSONNative = require_optional('bson-ext');
+  // If we got the native parser, use it instead of the
+  // Javascript one
+  if (BSONNative) {
+    BSON = BSONNative;
+  }
+} catch (err) {} // eslint-disable-line
+
+module.exports = {
+  // Errors
+  MongoError: require('./error').MongoError,
+  MongoNetworkError: require('./error').MongoNetworkError,
+  MongoParseError: require('./error').MongoParseError,
+  MongoTimeoutError: require('./error').MongoTimeoutError,
+  MongoWriteConcernError: require('./error').MongoWriteConcernError,
+  mongoErrorContextSymbol: require('./error').mongoErrorContextSymbol,
+  // Core
+  Connection: require('./connection/connection'),
+  Server: require('./topologies/server'),
+  ReplSet: require('./topologies/replset'),
+  Mongos: require('./topologies/mongos'),
+  Logger: require('./connection/logger'),
+  Cursor: require('./cursor'),
+  ReadPreference: require('./topologies/read_preference'),
+  Sessions: require('./sessions'),
+  BSON: BSON,
+  EJSON: EJSON,
+  Topology: require('./sdam/topology'),
+  // Raw operations
+  Query: require('./connection/commands').Query,
+  // Auth mechanisms
+  MongoCredentials: require('./auth/mongo_credentials').MongoCredentials,
+  defaultAuthProviders: require('./auth/defaultAuthProviders').defaultAuthProviders,
+  MongoCR: require('./auth/mongocr'),
+  X509: require('./auth/x509'),
+  Plain: require('./auth/plain'),
+  GSSAPI: require('./auth/gssapi'),
+  ScramSHA1: require('./auth/scram').ScramSHA1,
+  ScramSHA256: require('./auth/scram').ScramSHA256,
+  // Utilities
+  parseConnectionString: require('./uri_parser')
+};

package/lib/core/sdam/monitoring.js

@@ -0,0 +1,228 @@
+'use strict';
+
+const ServerDescription = require('./server_description').ServerDescription;
+const calculateDurationInMs = require('../utils').calculateDurationInMs;
+
+/**
+ * Published when server description changes, but does NOT include changes to the RTT.
+ *
+ * @property {Object} topologyId A unique identifier for the topology
+ * @property {ServerAddress} address The address (host/port pair) of the server
+ * @property {ServerDescription} previousDescription The previous server description
+ * @property {ServerDescription} newDescription The new server description
+ */
+class ServerDescriptionChangedEvent {
+  constructor(topologyId, address, previousDescription, newDescription) {
+    Object.assign(this, { topologyId, address, previousDescription, newDescription });
+  }
+}
+
+/**
+ * Published when server is initialized.
+ *
+ * @property {Object} topologyId A unique identifier for the topology
+ * @property {ServerAddress} address The address (host/port pair) of the server
+ */
+class ServerOpeningEvent {
+  constructor(topologyId, address) {
+    Object.assign(this, { topologyId, address });
+  }
+}
+
+/**
+ * Published when server is closed.
+ *
+ * @property {ServerAddress} address The address (host/port pair) of the server
+ * @property {Object} topologyId A unique identifier for the topology
+ */
+class ServerClosedEvent {
+  constructor(topologyId, address) {
+    Object.assign(this, { topologyId, address });
+  }
+}
+
+/**
+ * Published when topology description changes.
+ *
+ * @property {Object} topologyId
+ * @property {TopologyDescription} previousDescription The old topology description
+ * @property {TopologyDescription} newDescription The new topology description
+ */
+class TopologyDescriptionChangedEvent {
+  constructor(topologyId, previousDescription, newDescription) {
+    Object.assign(this, { topologyId, previousDescription, newDescription });
+  }
+}
+
+/**
+ * Published when topology is initialized.
+ *
+ * @param {Object} topologyId A unique identifier for the topology
+ */
+class TopologyOpeningEvent {
+  constructor(topologyId) {
+    Object.assign(this, { topologyId });
+  }
+}
+
+/**
+ * Published when topology is closed.
+ *
+ * @param {Object} topologyId A unique identifier for the topology
+ */
+class TopologyClosedEvent {
+  constructor(topologyId) {
+    Object.assign(this, { topologyId });
+  }
+}
+
+/**
+ * Fired when the server monitor’s ismaster command is started - immediately before
+ * the ismaster command is serialized into raw BSON and written to the socket.
+ *
+ * @property {Object} connectionId The connection id for the command
+ */
+class ServerHeartbeatStartedEvent {
+  constructor(connectionId) {
+    Object.assign(this, { connectionId });
+  }
+}
+
+/**
+ * Fired when the server monitor’s ismaster succeeds.
+ *
+ * @param {Number} duration The execution time of the event in ms
+ * @param {Object} reply The command reply
+ * @param {Object} connectionId The connection id for the command
+ */
+class ServerHeartbeatSucceededEvent {
+  constructor(duration, reply, connectionId) {
+    Object.assign(this, { duration, reply, connectionId });
+  }
+}
+
+/**
+ * Fired when the server monitor’s ismaster fails, either with an “ok: 0” or a socket exception.
+ *
+ * @param {Number} duration The execution time of the event in ms
+ * @param {MongoError|Object} failure The command failure
+ * @param {Object} connectionId The connection id for the command
+ */
+class ServerHeartbeatFailedEvent {
+  constructor(duration, failure, connectionId) {
+    Object.assign(this, { duration, failure, connectionId });
+  }
+}
+
+/**
+ * Performs a server check as described by the SDAM spec.
+ *
+ * NOTE: This method automatically reschedules itself, so that there is always an active
+ * monitoring process
+ *
+ * @param {Server} server The server to monitor
+ */
+function monitorServer(server, options) {
+  options = options || {};
+  const heartbeatFrequencyMS = options.heartbeatFrequencyMS || 10000;
+
+  if (options.initial === true) {
+    server.s.monitorId = setTimeout(() => monitorServer(server), heartbeatFrequencyMS);
+    return;
+  }
+
+  // executes a single check of a server
+  const checkServer = callback => {
+    let start = process.hrtime();
+
+    // emit a signal indicating we have started the heartbeat
+    server.emit('serverHeartbeatStarted', new ServerHeartbeatStartedEvent(server.name));
+
+    // NOTE: legacy monitoring event
+    process.nextTick(() => server.emit('monitoring', server));
+
+    server.command(
+      'admin.$cmd',
+      { ismaster: true },
+      {
+        monitoring: true,
+        socketTimeout: server.s.options.connectionTimeout || 2000
+      },
+      (err, result) => {
+        let duration = calculateDurationInMs(start);
+
+        if (err) {
+          server.emit(
+            'serverHeartbeatFailed',
+            new ServerHeartbeatFailedEvent(duration, err, server.name)
+          );
+
+          return callback(err, null);
+        }
+
+        const isMaster = result.result;
+        server.emit(
+          'serverHeartbeatSucceded',
+          new ServerHeartbeatSucceededEvent(duration, isMaster, server.name)
+        );
+
+        return callback(null, isMaster);
+      }
+    );
+  };
+
+  const successHandler = isMaster => {
+    server.s.monitoring = false;
+
+    // emit an event indicating that our description has changed
+    server.emit('descriptionReceived', new ServerDescription(server.description.address, isMaster));
+
+    // schedule the next monitoring process
+    server.s.monitorId = setTimeout(() => monitorServer(server), heartbeatFrequencyMS);
+  };
+
+  // run the actual monitoring loop
+  server.s.monitoring = true;
+  checkServer((err, isMaster) => {
+    if (!err) {
+      successHandler(isMaster);
+      return;
+    }
+
+    // According to the SDAM specification's "Network error during server check" section, if
+    // an ismaster call fails we reset the server's pool. If a server was once connected,
+    // change its type to `Unknown` only after retrying once.
+    server.s.pool.reset(() => {
+      // otherwise re-attempt monitoring once
+      checkServer((error, isMaster) => {
+        if (error) {
+          server.s.monitoring = false;
+
+          // we revert to an `Unknown` by emitting a default description with no isMaster
+          server.emit(
+            'descriptionReceived',
+            new ServerDescription(server.description.address, null, { error })
+          );
+
+          // we do not reschedule monitoring in this case
+          return;
+        }
+
+        successHandler(isMaster);
+      });
+    });
+  });
+}
+
+module.exports = {
+  ServerDescriptionChangedEvent,
+  ServerOpeningEvent,
+  ServerClosedEvent,
+  TopologyDescriptionChangedEvent,
+  TopologyOpeningEvent,
+  TopologyClosedEvent,
+  ServerHeartbeatStartedEvent,
+  ServerHeartbeatSucceededEvent,
+  ServerHeartbeatFailedEvent,
+  monitorServer
+};