mongodb 3.5.9 → 3.6.0

package/lib/core/sdam/common.js

@@ -28,6 +28,13 @@ const ServerType = {
   Unknown: 'Unknown'
 };
 
+// helper to get a server's type that works for both legacy and unified topologies
+function serverType(server) {
+  let description = server.s.description || server.s.serverDescription;
+  if (description.topologyType === TopologyType.Single) return description.servers[0].type;
+  return description.type;
+}
+
 const TOPOLOGY_DEFAULTS = {
   useUnifiedTopology: true,
   localThresholdMS: 15,
@@ -54,6 +61,7 @@ module.exports = {
   TOPOLOGY_DEFAULTS,
   TopologyType,
   ServerType,
+  serverType,
   drainTimerQueue,
   clearAndRemoveTimerFrom
 };

package/lib/core/sdam/monitor.js

@@ -6,7 +6,8 @@ const connect = require('../connection/connect');
 const Connection = require('../../cmap/connection').Connection;
 const common = require('./common');
 const makeStateMachine = require('../utils').makeStateMachine;
-const MongoError = require('../error').MongoError;
+const MongoNetworkError = require('../error').MongoNetworkError;
+const BSON = require('../connection/utils').retrieveBSON();
 const makeInterruptableAsyncInterval = require('../../utils').makeInterruptableAsyncInterval;
 const calculateDurationInMs = require('../../utils').calculateDurationInMs;
 const now = require('../../utils').now;
@@ -20,13 +21,15 @@ const kServer = Symbol('server');
 const kMonitorId = Symbol('monitorId');
 const kConnection = Symbol('connection');
 const kCancellationToken = Symbol('cancellationToken');
+const kRTTPinger = Symbol('rttPinger');
+const kRoundTripTime = Symbol('roundTripTime');
 
 const STATE_CLOSED = common.STATE_CLOSED;
 const STATE_CLOSING = common.STATE_CLOSING;
 const STATE_IDLE = 'idle';
 const STATE_MONITORING = 'monitoring';
 const stateTransition = makeStateMachine({
-  [STATE_CLOSING]: [STATE_CLOSING, STATE_CLOSED],
+  [STATE_CLOSING]: [STATE_CLOSING, STATE_IDLE, STATE_CLOSED],
   [STATE_CLOSED]: [STATE_CLOSED, STATE_MONITORING],
   [STATE_IDLE]: [STATE_IDLE, STATE_MONITORING, STATE_CLOSING],
   [STATE_MONITORING]: [STATE_MONITORING, STATE_IDLE, STATE_CLOSING]
@@ -66,28 +69,29 @@ class Monitor extends EventEmitter {
     });
 
     // TODO: refactor this to pull it directly from the pool, requires new ConnectionPool integration
-    const addressParts = server.description.address.split(':');
-    this.connectOptions = Object.freeze(
-      Object.assign(
-        {
-          id: '<monitor>',
-          host: addressParts[0],
-          port: parseInt(addressParts[1], 10),
-          bson: server.s.bson,
-          connectionType: Connection
-        },
-        server.s.options,
-        this.options,
-
-        // force BSON serialization options
-        {
-          raw: false,
-          promoteLongs: true,
-          promoteValues: true,
-          promoteBuffers: true
-        }
-      )
+    const connectOptions = Object.assign(
+      {
+        id: '<monitor>',
+        host: server.description.host,
+        port: server.description.port,
+        bson: server.s.bson,
+        connectionType: Connection
+      },
+      server.s.options,
+      this.options,
+
+      // force BSON serialization options
+      {
+        raw: false,
+        promoteLongs: true,
+        promoteValues: true,
+        promoteBuffers: true
+      }
     );
+
+    // ensure no authentication is used for monitoring
+    delete connectOptions.credentials;
+    this.connectOptions = Object.freeze(connectOptions);
   }
 
   connect() {
@@ -113,88 +117,165 @@ class Monitor extends EventEmitter {
     this[kMonitorId].wake();
   }
 
-  close() {
+  reset() {
     if (isInCloseState(this)) {
       return;
     }
 
     stateTransition(this, STATE_CLOSING);
-    this[kCancellationToken].emit('cancel');
-    if (this[kMonitorId]) {
-      this[kMonitorId].stop();
-      this[kMonitorId] = null;
-    }
+    resetMonitorState(this);
 
-    if (this[kConnection]) {
-      this[kConnection].destroy({ force: true });
+    // restart monitor
+    stateTransition(this, STATE_IDLE);
+
+    // restart monitoring
+    const heartbeatFrequencyMS = this.options.heartbeatFrequencyMS;
+    const minHeartbeatFrequencyMS = this.options.minHeartbeatFrequencyMS;
+    this[kMonitorId] = makeInterruptableAsyncInterval(monitorServer(this), {
+      interval: heartbeatFrequencyMS,
+      minInterval: minHeartbeatFrequencyMS
+    });
+  }
+
+  close() {
+    if (isInCloseState(this)) {
+      return;
     }
 
+    stateTransition(this, STATE_CLOSING);
+    resetMonitorState(this);
+
+    // close monitor
     this.emit('close');
     stateTransition(this, STATE_CLOSED);
   }
 }
 
-function checkServer(monitor, callback) {
-  if (monitor[kConnection] && monitor[kConnection].closed) {
-    monitor[kConnection] = undefined;
+function resetMonitorState(monitor) {
+  stateTransition(monitor, STATE_CLOSING);
+  if (monitor[kMonitorId]) {
+    monitor[kMonitorId].stop();
+    monitor[kMonitorId] = null;
   }
 
-  const start = now();
+  if (monitor[kRTTPinger]) {
+    monitor[kRTTPinger].close();
+    monitor[kRTTPinger] = undefined;
+  }
+
+  monitor[kCancellationToken].emit('cancel');
+  if (monitor[kMonitorId]) {
+    clearTimeout(monitor[kMonitorId]);
+    monitor[kMonitorId] = undefined;
+  }
+
+  if (monitor[kConnection]) {
+    monitor[kConnection].destroy({ force: true });
+  }
+}
+
+function checkServer(monitor, callback) {
+  let start = now();
   monitor.emit('serverHeartbeatStarted', new ServerHeartbeatStartedEvent(monitor.address));
 
   function failureHandler(err) {
+    if (monitor[kConnection]) {
+      monitor[kConnection].destroy({ force: true });
+      monitor[kConnection] = undefined;
+    }
+
     monitor.emit(
       'serverHeartbeatFailed',
       new ServerHeartbeatFailedEvent(calculateDurationInMs(start), err, monitor.address)
     );
 
+    monitor.emit('resetServer', err);
+    monitor.emit('resetConnectionPool');
     callback(err);
   }
 
-  function successHandler(isMaster) {
-    monitor.emit(
-      'serverHeartbeatSucceeded',
-      new ServerHeartbeatSucceededEvent(calculateDurationInMs(start), isMaster, monitor.address)
-    );
+  if (monitor[kConnection] != null && !monitor[kConnection].closed) {
+    const connectTimeoutMS = monitor.options.connectTimeoutMS;
+    const maxAwaitTimeMS = monitor.options.heartbeatFrequencyMS;
+    const topologyVersion = monitor[kServer].description.topologyVersion;
+    const isAwaitable = topologyVersion != null;
 
-    return callback(undefined, isMaster);
-  }
+    const cmd = isAwaitable
+      ? { ismaster: true, maxAwaitTimeMS, topologyVersion: makeTopologyVersion(topologyVersion) }
+      : { ismaster: true };
 
-  if (monitor[kConnection] != null) {
-    const connectTimeoutMS = monitor.options.connectTimeoutMS;
-    monitor[kConnection].command(
-      'admin.$cmd',
-      { ismaster: true },
-      { socketTimeout: connectTimeoutMS },
-      (err, result) => {
-        if (err) {
-          failureHandler(err);
-          return;
+    const options = isAwaitable
+      ? { socketTimeout: connectTimeoutMS + maxAwaitTimeMS, exhaustAllowed: true }
+      : { socketTimeout: connectTimeoutMS };
+
+    if (isAwaitable && monitor[kRTTPinger] == null) {
+      monitor[kRTTPinger] = new RTTPinger(monitor[kCancellationToken], monitor.connectOptions);
+    }
+
+    monitor[kConnection].command('admin.$cmd', cmd, options, (err, result) => {
+      if (err) {
+        failureHandler(err);
+        return;
+      }
+
+      const isMaster = result.result;
+      const duration = isAwaitable
+        ? monitor[kRTTPinger].roundTripTime
+        : calculateDurationInMs(start);
+
+      monitor.emit(
+        'serverHeartbeatSucceeded',
+        new ServerHeartbeatSucceededEvent(duration, isMaster, monitor.address)
+      );
+
+      // if we are using the streaming protocol then we immediately issue another `started`
+      // event, otherwise the "check" is complete and return to the main monitor loop
+      if (isAwaitable && isMaster.topologyVersion) {
+        monitor.emit('serverHeartbeatStarted', new ServerHeartbeatStartedEvent(monitor.address));
+        start = now();
+      } else {
+        if (monitor[kRTTPinger]) {
+          monitor[kRTTPinger].close();
+          monitor[kRTTPinger] = undefined;
         }
 
-        successHandler(result.result);
+        callback(undefined, isMaster);
       }
-    );
+    });
 
     return;
   }
 
   // connecting does an implicit `ismaster`
   connect(monitor.connectOptions, monitor[kCancellationToken], (err, conn) => {
-    if (err) {
-      monitor[kConnection] = undefined;
-      failureHandler(err);
+    if (conn && isInCloseState(monitor)) {
+      conn.destroy({ force: true });
       return;
     }
 
-    if (isInCloseState(monitor)) {
-      conn.destroy({ force: true });
-      failureHandler(new MongoError('monitor was destroyed'));
+    if (err) {
+      monitor[kConnection] = undefined;
+
+      // we already reset the connection pool on network errors in all cases
+      if (!(err instanceof MongoNetworkError)) {
+        monitor.emit('resetConnectionPool');
+      }
+
+      failureHandler(err);
       return;
     }
 
     monitor[kConnection] = conn;
-    successHandler(conn.ismaster);
+    monitor.emit(
+      'serverHeartbeatSucceeded',
+      new ServerHeartbeatSucceededEvent(
+        calculateDurationInMs(start),
+        conn.ismaster,
+        monitor.address
+      )
+    );
+
+    callback(undefined, conn.ismaster);
   });
 }
 
@@ -212,31 +293,111 @@ function monitorServer(monitor) {
     // TODO: the next line is a legacy event, remove in v4
     process.nextTick(() => monitor.emit('monitoring', monitor[kServer]));
 
-    checkServer(monitor, e0 => {
-      if (e0 == null) {
-        return done();
+    checkServer(monitor, (err, isMaster) => {
+      if (err) {
+        // otherwise an error occured on initial discovery, also bail
+        if (monitor[kServer].description.type === ServerType.Unknown) {
+          monitor.emit('resetServer', err);
+          return done();
+        }
       }
 
-      // otherwise an error occured on initial discovery, also bail
-      if (monitor[kServer].description.type === ServerType.Unknown) {
-        monitor.emit('resetServer', e0);
-        return done();
+      // if the check indicates streaming is supported, immediately reschedule monitoring
+      if (isMaster && isMaster.topologyVersion) {
+        setTimeout(() => {
+          if (!isInCloseState(monitor)) {
+            monitor[kMonitorId].wake();
+          }
+        });
       }
 
-      // 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.
-      monitor.emit('resetConnectionPool');
+      done();
+    });
+  };
+}
 
-      checkServer(monitor, e1 => {
-        if (e1) {
-          monitor.emit('resetServer', e1);
-        }
+function makeTopologyVersion(tv) {
+  return {
+    processId: tv.processId,
+    counter: BSON.Long.fromNumber(tv.counter)
+  };
+}
+
+class RTTPinger {
+  constructor(cancellationToken, options) {
+    this[kConnection] = null;
+    this[kCancellationToken] = cancellationToken;
+    this[kRoundTripTime] = 0;
+    this.closed = false;
+
+    const heartbeatFrequencyMS = options.heartbeatFrequencyMS;
+    this[kMonitorId] = setTimeout(() => measureRoundTripTime(this, options), heartbeatFrequencyMS);
+  }
+
+  get roundTripTime() {
+    return this[kRoundTripTime];
+  }
+
+  close() {
+    this.closed = true;
+
+    clearTimeout(this[kMonitorId]);
+    this[kMonitorId] = undefined;
+
+    if (this[kConnection]) {
+      this[kConnection].destroy({ force: true });
+    }
+  }
+}
+
+function measureRoundTripTime(rttPinger, options) {
+  const start = now();
+  const cancellationToken = rttPinger[kCancellationToken];
+  const heartbeatFrequencyMS = options.heartbeatFrequencyMS;
+  if (rttPinger.closed) {
+    return;
+  }
+
+  function measureAndReschedule(conn) {
+    if (rttPinger.closed) {
+      conn.destroy({ force: true });
+      return;
+    }
 
-        done();
-      });
+    if (rttPinger[kConnection] == null) {
+      rttPinger[kConnection] = conn;
+    }
+
+    rttPinger[kRoundTripTime] = calculateDurationInMs(start);
+    rttPinger[kMonitorId] = setTimeout(
+      () => measureRoundTripTime(rttPinger, options),
+      heartbeatFrequencyMS
+    );
+  }
+
+  if (rttPinger[kConnection] == null) {
+    connect(options, cancellationToken, (err, conn) => {
+      if (err) {
+        rttPinger[kConnection] = undefined;
+        rttPinger[kRoundTripTime] = 0;
+        return;
+      }
+
+      measureAndReschedule(conn);
     });
-  };
+
+    return;
+  }
+
+  rttPinger[kConnection].command('admin.$cmd', { ismaster: 1 }, err => {
+    if (err) {
+      rttPinger[kConnection] = undefined;
+      rttPinger[kRoundTripTime] = 0;
+      return;
+    }
+
+    measureAndReschedule();
+  });
 }
 
 module.exports = {

package/lib/core/sdam/server.js

@@ -7,17 +7,22 @@ const relayEvents = require('../utils').relayEvents;
 const BSON = require('../connection/utils').retrieveBSON();
 const Logger = require('../connection/logger');
 const ServerDescription = require('./server_description').ServerDescription;
+const compareTopologyVersion = require('./server_description').compareTopologyVersion;
 const ReadPreference = require('../topologies/read_preference');
 const Monitor = require('./monitor').Monitor;
 const MongoNetworkError = require('../error').MongoNetworkError;
+const MongoNetworkTimeoutError = require('../error').MongoNetworkTimeoutError;
 const collationNotSupported = require('../utils').collationNotSupported;
 const debugOptions = require('../connection/utils').debugOptions;
 const isSDAMUnrecoverableError = require('../error').isSDAMUnrecoverableError;
-const isNetworkTimeoutError = require('../error').isNetworkTimeoutError;
+const isRetryableWriteError = require('../error').isRetryableWriteError;
 const isNodeShuttingDownError = require('../error').isNodeShuttingDownError;
+const isNetworkErrorBeforeHandshake = require('../error').isNetworkErrorBeforeHandshake;
 const maxWireVersion = require('../utils').maxWireVersion;
 const makeStateMachine = require('../utils').makeStateMachine;
 const common = require('./common');
+const ServerType = common.ServerType;
+const isTransactionCommand = require('../transactions').isTransactionCommand;
 
 // Used for filtering out fields for logging
 const DEBUG_FIELDS = [
@@ -110,9 +115,8 @@ class Server extends EventEmitter {
 
     // create the connection pool
     // NOTE: this used to happen in `connect`, we supported overriding pool options there
-    const addressParts = this.description.address.split(':');
     const poolOptions = Object.assign(
-      { host: addressParts[0], port: parseInt(addressParts[1], 10), bson: this.s.bson },
+      { host: this.description.host, port: this.description.port, bson: this.s.bson },
       options
     );
 
@@ -278,7 +282,7 @@ class Server extends EventEmitter {
         return cb(err);
       }
 
-      conn.command(ns, cmd, options, makeOperationHandler(this, options, cb));
+      conn.command(ns, cmd, options, makeOperationHandler(this, conn, cmd, options, cb));
     }, callback);
   }
 
@@ -302,7 +306,7 @@ class Server extends EventEmitter {
         return cb(err);
       }
 
-      conn.query(ns, cmd, cursorState, options, makeOperationHandler(this, options, cb));
+      conn.query(ns, cmd, cursorState, options, makeOperationHandler(this, conn, cmd, options, cb));
     }, callback);
   }
 
@@ -326,7 +330,13 @@ class Server extends EventEmitter {
         return cb(err);
       }
 
-      conn.getMore(ns, cursorState, batchSize, options, makeOperationHandler(this, options, cb));
+      conn.getMore(
+        ns,
+        cursorState,
+        batchSize,
+        options,
+        makeOperationHandler(this, conn, null, options, cb)
+      );
     }, callback);
   }
 
@@ -352,7 +362,7 @@ class Server extends EventEmitter {
         return cb(err);
       }
 
-      conn.killCursors(ns, cursorState, makeOperationHandler(this, null, cb));
+      conn.killCursors(ns, cursorState, makeOperationHandler(this, conn, null, undefined, cb));
     }, callback);
   }
 
@@ -414,6 +424,14 @@ Object.defineProperty(Server.prototype, 'clusterTime', {
   }
 });
 
+function supportsRetryableWrites(server) {
+  return (
+    server.description.maxWireVersion >= 6 &&
+    server.description.logicalSessionTimeoutMinutes &&
+    server.description.type !== ServerType.Standalone
+  );
+}
+
 function calculateRoundTripTime(oldRtt, duration) {
   if (oldRtt === -1) {
     return duration;
@@ -448,6 +466,13 @@ function executeWriteOperation(args, options, callback) {
     callback(new MongoError(`server ${server.name} does not support collation`));
     return;
   }
+  const unacknowledgedWrite = options.writeConcern && options.writeConcern.w === 0;
+  if (unacknowledgedWrite || maxWireVersion(server) < 5) {
+    if ((op === 'update' || op === 'remove') && ops.find(o => o.hint)) {
+      callback(new MongoError(`servers < 3.4 do not support hint on ${op}`));
+      return;
+    }
+  }
 
   server.s.pool.withConnection((err, conn, cb) => {
     if (err) {
@@ -455,38 +480,78 @@ function executeWriteOperation(args, options, callback) {
       return cb(err);
     }
 
-    conn[op](ns, ops, options, makeOperationHandler(server, options, cb));
+    conn[op](ns, ops, options, makeOperationHandler(server, conn, ops, options, cb));
   }, callback);
 }
 
 function markServerUnknown(server, error) {
+  if (error instanceof MongoNetworkError && !(error instanceof MongoNetworkTimeoutError)) {
+    server[kMonitor].reset();
+  }
+
   server.emit(
     'descriptionReceived',
-    new ServerDescription(server.description.address, null, { error })
+    new ServerDescription(server.description.address, null, {
+      error,
+      topologyVersion:
+        error && error.topologyVersion ? error.topologyVersion : server.description.topologyVersion
+    })
   );
 }
 
-function makeOperationHandler(server, options, callback) {
+function connectionIsStale(pool, connection) {
+  return connection.generation !== pool.generation;
+}
+
+function shouldHandleStateChangeError(server, err) {
+  const etv = err.topologyVersion;
+  const stv = server.description.topologyVersion;
+
+  return compareTopologyVersion(stv, etv) < 0;
+}
+
+function inActiveTransaction(session, cmd) {
+  return session && session.inTransaction() && !isTransactionCommand(cmd);
+}
+
+function makeOperationHandler(server, connection, cmd, options, callback) {
   const session = options && options.session;
 
   return function handleOperationResult(err, result) {
-    if (err) {
+    if (err && !connectionIsStale(server.s.pool, connection)) {
       if (err instanceof MongoNetworkError) {
         if (session && !session.hasEnded) {
           session.serverSession.isDirty = true;
         }
 
-        if (!isNetworkTimeoutError(err)) {
+        if (supportsRetryableWrites(server) && !inActiveTransaction(session, cmd)) {
+          err.addErrorLabel('RetryableWriteError');
+        }
+
+        if (!(err instanceof MongoNetworkTimeoutError) || isNetworkErrorBeforeHandshake(err)) {
           markServerUnknown(server, err);
           server.s.pool.clear();
         }
-      } else if (isSDAMUnrecoverableError(err)) {
-        if (maxWireVersion(server) <= 7 || isNodeShuttingDownError(err)) {
-          server.s.pool.clear();
+      } else {
+        // if pre-4.4 server, then add error label if its a retryable write error
+        if (
+          maxWireVersion(server) < 9 &&
+          isRetryableWriteError(err) &&
+          !inActiveTransaction(session, cmd)
+        ) {
+          err.addErrorLabel('RetryableWriteError');
         }
 
-        markServerUnknown(server, err);
-        process.nextTick(() => server.requestCheck());
+        if (isSDAMUnrecoverableError(err)) {
+          if (shouldHandleStateChangeError(server, err)) {
+            if (maxWireVersion(server) <= 7 || isNodeShuttingDownError(err)) {
+              server.s.pool.clear();
+            }
+
+            markServerUnknown(server, err);
+            process.nextTick(() => server.requestCheck());
+          }
+        }
       }
     }