mongodb 4.0.0 → 4.1.2

package/src/sdam/common.ts

@@ -17,7 +17,8 @@ export const TopologyType = Object.freeze({
   ReplicaSetNoPrimary: 'ReplicaSetNoPrimary',
   ReplicaSetWithPrimary: 'ReplicaSetWithPrimary',
   Sharded: 'Sharded',
-  Unknown: 'Unknown'
+  Unknown: 'Unknown',
+  LoadBalanced: 'LoadBalanced'
 } as const);
 
 /** @public */
@@ -36,7 +37,8 @@ export const ServerType = Object.freeze({
   RSArbiter: 'RSArbiter',
   RSOther: 'RSOther',
   RSGhost: 'RSGhost',
-  Unknown: 'Unknown'
+  Unknown: 'Unknown',
+  LoadBalancer: 'LoadBalancer'
 } as const);
 
 /** @public */
@@ -66,16 +68,16 @@ export interface ClusterTime {
   };
 }
 
-/** Shared function to determine clusterTime for a given topology */
-export function resolveClusterTime(
-  topology: Topology | ClientSession,
+/** Shared function to determine clusterTime for a given topology or session */
+export function _advanceClusterTime(
+  entity: Topology | ClientSession,
   $clusterTime: ClusterTime
 ): void {
-  if (topology.clusterTime == null) {
-    topology.clusterTime = $clusterTime;
+  if (entity.clusterTime == null) {
+    entity.clusterTime = $clusterTime;
   } else {
-    if ($clusterTime.clusterTime.greaterThan(topology.clusterTime.clusterTime)) {
-      topology.clusterTime = $clusterTime;
+    if ($clusterTime.clusterTime.greaterThan(entity.clusterTime.clusterTime)) {
+      entity.clusterTime = $clusterTime;
     }
   }
 }

package/src/sdam/server.ts

@@ -18,12 +18,12 @@ import {
   EventEmitterWithState
 } from '../utils';
 import {
-  ServerType,
   STATE_CLOSED,
   STATE_CLOSING,
   STATE_CONNECTING,
   STATE_CONNECTED,
-  ClusterTime
+  ClusterTime,
+  TopologyType
 } from './common';
 import {
   MongoError,
@@ -33,7 +33,9 @@ import {
   isRetryableWriteError,
   isNodeShuttingDownError,
   isNetworkErrorBeforeHandshake,
-  MongoDriverError
+  MongoCompatibilityError,
+  MongoInvalidArgumentError,
+  MongoServerClosedError
 } from '../error';
 import {
   Connection,
@@ -54,6 +56,7 @@ import type { Document, Long } from '../bson';
 import type { AutoEncrypter } from '../deps';
 import type { ServerApi } from '../mongo_client';
 import { TypedEventEmitter } from '../mongo_types';
+import { supportsRetryableWrites } from '../utils';
 
 const stateTransition = makeStateMachine({
   [STATE_CLOSED]: [STATE_CLOSED, STATE_CONNECTING],
@@ -151,6 +154,9 @@ export class Server extends TypedEventEmitter<ServerEvents> {
       this.clusterTime = clusterTime;
     });
 
+    // monitoring is disabled in load balancing mode
+    if (this.loadBalanced) return;
+
     // create the monitor
     this[kMonitor] = new Monitor(this, this.s.options);
 
@@ -192,6 +198,10 @@ export class Server extends TypedEventEmitter<ServerEvents> {
     }
   }
 
+  get loadBalanced(): boolean {
+    return this.s.topology.description.type === TopologyType.LoadBalanced;
+  }
+
   /**
    * Initiate server connect
    */
@@ -201,7 +211,16 @@ export class Server extends TypedEventEmitter<ServerEvents> {
     }
 
     stateTransition(this, STATE_CONNECTING);
-    this[kMonitor].connect();
+
+    // If in load balancer mode we automatically set the server to
+    // a load balancer. It never transitions out of this state and
+    // has no monitor.
+    if (!this.loadBalanced) {
+      this[kMonitor].connect();
+    } else {
+      stateTransition(this, STATE_CONNECTED);
+      this.emit(Server.CONNECT, this);
+    }
   }
 
   /** Destroy the server connection */
@@ -219,7 +238,10 @@ export class Server extends TypedEventEmitter<ServerEvents> {
 
     stateTransition(this, STATE_CLOSING);
 
-    this[kMonitor].close();
+    if (!this.loadBalanced) {
+      this[kMonitor].close();
+    }
+
     this.s.pool.close(options, err => {
       stateTransition(this, STATE_CLOSED);
       this.emit('closed');
@@ -234,7 +256,9 @@ export class Server extends TypedEventEmitter<ServerEvents> {
    * this will be a no-op.
    */
   requestCheck(): void {
-    this[kMonitor].requestCheck();
+    if (!this.loadBalanced) {
+      this[kMonitor].requestCheck();
+    }
   }
 
   /**
@@ -260,15 +284,15 @@ export class Server extends TypedEventEmitter<ServerEvents> {
     }
 
     if (callback == null) {
-      throw new MongoDriverError('callback must be provided');
+      throw new MongoInvalidArgumentError('Callback must be provided');
     }
 
     if (ns.db == null || typeof ns === 'string') {
-      throw new MongoDriverError('ns must not be a string');
+      throw new MongoInvalidArgumentError('Namespace must not be a string');
     }
 
     if (this.s.state === STATE_CLOSING || this.s.state === STATE_CLOSED) {
-      callback(new MongoDriverError('server is closed'));
+      callback(new MongoServerClosedError());
       return;
     }
 
@@ -277,23 +301,47 @@ export class Server extends TypedEventEmitter<ServerEvents> {
 
     // error if collation not supported
     if (collationNotSupported(this, cmd)) {
-      callback(new MongoDriverError(`server ${this.name} does not support collation`));
+      callback(new MongoCompatibilityError(`Server ${this.name} does not support collation`));
       return;
     }
 
-    this.s.pool.withConnection((err, conn, cb) => {
-      if (err || !conn) {
-        markServerUnknown(this, err);
-        return cb(err);
-      }
+    const session = finalOptions.session;
+    const conn = session?.pinnedConnection;
+
+    // NOTE: This is a hack! We can't retrieve the connections used for executing an operation
+    //       (and prevent them from being checked back in) at the point of operation execution.
+    //       This should be considered as part of the work for NODE-2882
+    if (this.loadBalanced && session && conn == null && isPinnableCommand(cmd, session)) {
+      this.s.pool.checkOut((err, checkedOut) => {
+        if (err || checkedOut == null) {
+          if (callback) return callback(err);
+          return;
+        }
 
-      conn.command(
-        ns,
-        cmd,
-        finalOptions,
-        makeOperationHandler(this, conn, cmd, finalOptions, cb) as Callback<Document>
-      );
-    }, callback);
+        session.pin(checkedOut);
+        this.command(ns, cmd, finalOptions, callback as Callback<Document>);
+      });
+
+      return;
+    }
+
+    this.s.pool.withConnection(
+      conn,
+      (err, conn, cb) => {
+        if (err || !conn) {
+          markServerUnknown(this, err);
+          return cb(err);
+        }
+
+        conn.command(
+          ns,
+          cmd,
+          finalOptions,
+          makeOperationHandler(this, conn, cmd, finalOptions, cb) as Callback<Document>
+        );
+      },
+      callback
+    );
   }
 
   /**
@@ -302,18 +350,27 @@ export class Server extends TypedEventEmitter<ServerEvents> {
    */
   query(ns: MongoDBNamespace, cmd: Document, options: QueryOptions, callback: Callback): void {
     if (this.s.state === STATE_CLOSING || this.s.state === STATE_CLOSED) {
-      callback(new MongoDriverError('server is closed'));
+      callback(new MongoServerClosedError());
       return;
     }
 
-    this.s.pool.withConnection((err, conn, cb) => {
-      if (err || !conn) {
-        markServerUnknown(this, err);
-        return cb(err);
-      }
+    this.s.pool.withConnection(
+      undefined,
+      (err, conn, cb) => {
+        if (err || !conn) {
+          markServerUnknown(this, err);
+          return cb(err);
+        }
 
-      conn.query(ns, cmd, options, makeOperationHandler(this, conn, cmd, options, cb) as Callback);
-    }, callback);
+        conn.query(
+          ns,
+          cmd,
+          options,
+          makeOperationHandler(this, conn, cmd, options, cb) as Callback
+        );
+      },
+      callback
+    );
   }
 
   /**
@@ -327,23 +384,27 @@ export class Server extends TypedEventEmitter<ServerEvents> {
     callback: Callback<Document>
   ): void {
     if (this.s.state === STATE_CLOSING || this.s.state === STATE_CLOSED) {
-      callback(new MongoDriverError('server is closed'));
+      callback(new MongoServerClosedError());
       return;
     }
 
-    this.s.pool.withConnection((err, conn, cb) => {
-      if (err || !conn) {
-        markServerUnknown(this, err);
-        return cb(err);
-      }
+    this.s.pool.withConnection(
+      options.session?.pinnedConnection,
+      (err, conn, cb) => {
+        if (err || !conn) {
+          markServerUnknown(this, err);
+          return cb(err);
+        }
 
-      conn.getMore(
-        ns,
-        cursorId,
-        options,
-        makeOperationHandler(this, conn, {}, options, cb) as Callback
-      );
-    }, callback);
+        conn.getMore(
+          ns,
+          cursorId,
+          options,
+          makeOperationHandler(this, conn, {}, options, cb) as Callback
+        );
+      },
+      callback
+    );
   }
 
   /**
@@ -358,25 +419,29 @@ export class Server extends TypedEventEmitter<ServerEvents> {
   ): void {
     if (this.s.state === STATE_CLOSING || this.s.state === STATE_CLOSED) {
       if (typeof callback === 'function') {
-        callback(new MongoDriverError('server is closed'));
+        callback(new MongoServerClosedError());
       }
 
       return;
     }
 
-    this.s.pool.withConnection((err, conn, cb) => {
-      if (err || !conn) {
-        markServerUnknown(this, err);
-        return cb(err);
-      }
+    this.s.pool.withConnection(
+      options.session?.pinnedConnection,
+      (err, conn, cb) => {
+        if (err || !conn) {
+          markServerUnknown(this, err);
+          return cb(err);
+        }
 
-      conn.killCursors(
-        ns,
-        cursorIds,
-        options,
-        makeOperationHandler(this, conn, {}, undefined, cb) as Callback
-      );
-    }, callback);
+        conn.killCursors(
+          ns,
+          cursorIds,
+          options,
+          makeOperationHandler(this, conn, {}, undefined, cb) as Callback
+        );
+      },
+      callback
+    );
   }
 }
 
@@ -395,14 +460,6 @@ Object.defineProperty(Server.prototype, 'clusterTime', {
   }
 });
 
-function supportsRetryableWrites(server: Server) {
-  return (
-    server.description.maxWireVersion >= 6 &&
-    server.description.logicalSessionTimeoutMinutes &&
-    server.description.type !== ServerType.Standalone
-  );
-}
-
 function calculateRoundTripTime(oldRtt: number, duration: number): number {
   if (oldRtt === -1) {
     return duration;
@@ -413,6 +470,11 @@ function calculateRoundTripTime(oldRtt: number, duration: number): number {
 }
 
 function markServerUnknown(server: Server, error?: MongoError) {
+  // Load balancer servers can never be marked unknown.
+  if (server.loadBalanced) {
+    return;
+  }
+
   if (error instanceof MongoNetworkError && !(error instanceof MongoNetworkTimeoutError)) {
     server[kMonitor].reset();
   }
@@ -427,7 +489,28 @@ function markServerUnknown(server: Server, error?: MongoError) {
   );
 }
 
+function isPinnableCommand(cmd: Document, session?: ClientSession): boolean {
+  if (session) {
+    return (
+      session.inTransaction() ||
+      'aggregate' in cmd ||
+      'find' in cmd ||
+      'getMore' in cmd ||
+      'listCollections' in cmd ||
+      'listIndexes' in cmd
+    );
+  }
+
+  return false;
+}
+
 function connectionIsStale(pool: ConnectionPool, connection: Connection) {
+  if (connection.serviceId) {
+    return (
+      connection.generation !== pool.serviceGenerations.get(connection.serviceId.toHexString())
+    );
+  }
+
   return connection.generation !== pool.generation;
 }
 
@@ -462,6 +545,11 @@ function makeOperationHandler(
           session.serverSession.isDirty = true;
         }
 
+        // inActiveTransaction check handles commit and abort.
+        if (inActiveTransaction(session, cmd) && !err.hasErrorLabel('TransientTransactionError')) {
+          err.addErrorLabel('TransientTransactionError');
+        }
+
         if (
           (isRetryableWritesEnabled(server.s.topology) || isTransactionCommand(cmd)) &&
           supportsRetryableWrites(server) &&
@@ -471,8 +559,13 @@ function makeOperationHandler(
         }
 
         if (!(err instanceof MongoNetworkTimeoutError) || isNetworkErrorBeforeHandshake(err)) {
-          markServerUnknown(server, err);
-          server.s.pool.clear();
+          // In load balanced mode we never mark the server as unknown and always
+          // clear for the specific service id.
+
+          server.s.pool.clear(connection.serviceId);
+          if (!server.loadBalanced) {
+            markServerUnknown(server, err);
+          }
         }
       } else {
         // if pre-4.4 server, then add error label if its a retryable write error
@@ -488,14 +581,20 @@ function makeOperationHandler(
         if (isSDAMUnrecoverableError(err)) {
           if (shouldHandleStateChangeError(server, err)) {
             if (maxWireVersion(server) <= 7 || isNodeShuttingDownError(err)) {
-              server.s.pool.clear();
+              server.s.pool.clear(connection.serviceId);
             }
 
-            markServerUnknown(server, err);
-            process.nextTick(() => server.requestCheck());
+            if (!server.loadBalanced) {
+              markServerUnknown(server, err);
+              process.nextTick(() => server.requestCheck());
+            }
           }
         }
       }
+
+      if (session && session.isPinned && err.hasErrorLabel('TransientTransactionError')) {
+        session.unpin({ force: true });
+      }
     }
 
     callback(err, result);

package/src/sdam/server_description.ts

@@ -7,14 +7,16 @@ import type { MongoError } from '../error';
 const WRITABLE_SERVER_TYPES = new Set<ServerType>([
   ServerType.RSPrimary,
   ServerType.Standalone,
-  ServerType.Mongos
+  ServerType.Mongos,
+  ServerType.LoadBalancer
 ]);
 
 const DATA_BEARING_SERVER_TYPES = new Set<ServerType>([
   ServerType.RSPrimary,
   ServerType.RSSecondary,
   ServerType.Mongos,
-  ServerType.Standalone
+  ServerType.Standalone,
+  ServerType.LoadBalancer
 ]);
 
 /** @public */
@@ -36,6 +38,9 @@ export interface ServerDescriptionOptions {
 
   /** The topologyVersion */
   topologyVersion?: TopologyVersion;
+
+  /** If the client is in load balancing mode. */
+  loadBalanced?: boolean;
 }
 
 /**
@@ -90,7 +95,7 @@ export class ServerDescription {
       this._hostAddress = address;
       this.address = this._hostAddress.toString();
     }
-    this.type = parseServerType(ismaster);
+    this.type = parseServerType(ismaster, options);
     this.hosts = ismaster?.hosts?.map((host: string) => host.toLowerCase()) ?? [];
     this.passives = ismaster?.passives?.map((host: string) => host.toLowerCase()) ?? [];
     this.arbiters = ismaster?.arbiters?.map((host: string) => host.toLowerCase()) ?? [];
@@ -206,7 +211,14 @@ export class ServerDescription {
 }
 
 // Parses an `ismaster` message and determines the server type
-export function parseServerType(ismaster?: Document): ServerType {
+export function parseServerType(
+  ismaster?: Document,
+  options?: ServerDescriptionOptions
+): ServerType {
+  if (options?.loadBalanced) {
+    return ServerType.LoadBalancer;
+  }
+
   if (!ismaster || !ismaster.ok) {
     return ServerType.Unknown;
   }

package/src/sdam/server_selection.ts

@@ -1,6 +1,6 @@
 import { ServerType, TopologyType } from './common';
 import { ReadPreference } from '../read_preference';
-import { MongoDriverError } from '../error';
+import { MongoCompatibilityError, MongoInvalidArgumentError } from '../error';
 import type { TopologyDescription } from './topology_description';
 import type { ServerDescription, TagSet } from './server_description';
 
@@ -50,14 +50,14 @@ function maxStalenessReducer(
   const maxStalenessVariance =
     (topologyDescription.heartbeatFrequencyMS + IDLE_WRITE_PERIOD) / 1000;
   if (maxStaleness < maxStalenessVariance) {
-    throw new MongoDriverError(
-      `maxStalenessSeconds must be at least ${maxStalenessVariance} seconds`
+    throw new MongoInvalidArgumentError(
+      `Option "maxStalenessSeconds" must be at least ${maxStalenessVariance} seconds`
     );
   }
 
   if (maxStaleness < SMALLEST_MAX_STALENESS_SECONDS) {
-    throw new MongoDriverError(
-      `maxStalenessSeconds must be at least ${SMALLEST_MAX_STALENESS_SECONDS} seconds`
+    throw new MongoInvalidArgumentError(
+      `Option "maxStalenessSeconds" must be at least ${SMALLEST_MAX_STALENESS_SECONDS} seconds`
     );
   }
 
@@ -207,6 +207,10 @@ function knownFilter(server: ServerDescription): boolean {
   return server.type !== ServerType.Unknown;
 }
 
+function loadBalancerFilter(server: ServerDescription): boolean {
+  return server.type === ServerType.LoadBalancer;
+}
+
 /**
  * Returns a function which selects servers based on a provided read preference
  *
@@ -214,7 +218,7 @@ function knownFilter(server: ServerDescription): boolean {
  */
 export function readPreferenceServerSelector(readPreference: ReadPreference): ServerSelector {
   if (!readPreference.isValid()) {
-    throw new MongoDriverError('Invalid read preference specified');
+    throw new MongoInvalidArgumentError('Invalid read preference specified');
   }
 
   return (
@@ -227,11 +231,15 @@ export function readPreferenceServerSelector(readPreference: ReadPreference): Se
       readPreference.minWireVersion &&
       readPreference.minWireVersion > commonWireVersion
     ) {
-      throw new MongoDriverError(
+      throw new MongoCompatibilityError(
         `Minimum wire version '${readPreference.minWireVersion}' required, but found '${commonWireVersion}'`
       );
     }
 
+    if (topologyDescription.type === TopologyType.LoadBalanced) {
+      return servers.filter(loadBalancerFilter);
+    }
+
     if (topologyDescription.type === TopologyType.Unknown) {
       return [];
     }

package/src/sdam/srv_polling.ts

@@ -2,7 +2,7 @@ import * as dns from 'dns';
 import { Logger, LoggerOptions } from '../logger';
 import { HostAddress } from '../utils';
 import { TypedEventEmitter } from '../mongo_types';
-import { MongoDriverError } from '../error';
+import { MongoRuntimeError } from '../error';
 
 /**
  * Determines whether a provided address matches the provided parent domain in order
@@ -67,7 +67,7 @@ export class SrvPoller extends TypedEventEmitter<SrvPollerEvents> {
     super();
 
     if (!options || !options.srvHost) {
-      throw new MongoDriverError('options for SrvPoller must exist and include srvHost');
+      throw new MongoRuntimeError('Options for SrvPoller must exist and include srvHost');
     }
 
     this.srvHost = options.srvHost;