mongodb 4.1.4 → 4.3.0

package/src/sdam/topology.ts

@@ -1,87 +1,83 @@
 import Denque = require('denque');
-import { ReadPreference, ReadPreferenceLike } from '../read_preference';
-import { compareTopologyVersion, ServerDescription } from './server_description';
-import { TopologyDescription } from './topology_description';
-import { Server, ServerEvents, ServerOptions } from './server';
+import type { BSONSerializeOptions, Document } from '../bson';
+import { deserialize, serialize } from '../bson';
+import type { MongoCredentials } from '../cmap/auth/mongo_credentials';
+import type { ConnectionEvents, DestroyOptions } from '../cmap/connection';
+import type { CloseOptions, ConnectionPoolEvents } from '../cmap/connection_pool';
+import { DEFAULT_OPTIONS } from '../connection_string';
 import {
-  ClientSession,
-  ServerSessionPool,
-  ServerSessionId,
-  ClientSessionOptions
-} from '../sessions';
-import { SrvPoller, SrvPollingEvent } from './srv_polling';
-import { CMAP_EVENTS, ConnectionPoolEvents } from '../cmap/connection_pool';
+  CLOSE,
+  CONNECT,
+  ERROR,
+  LOCAL_SERVER_EVENTS,
+  OPEN,
+  SERVER_CLOSED,
+  SERVER_DESCRIPTION_CHANGED,
+  SERVER_OPENING,
+  SERVER_RELAY_EVENTS,
+  TIMEOUT,
+  TOPOLOGY_CLOSED,
+  TOPOLOGY_DESCRIPTION_CHANGED,
+  TOPOLOGY_OPENING
+} from '../constants';
 import {
-  MongoServerSelectionError,
   MongoCompatibilityError,
   MongoDriverError,
-  MongoTopologyClosedError,
-  MongoRuntimeError
+  MongoRuntimeError,
+  MongoServerSelectionError,
+  MongoTopologyClosedError
 } from '../error';
-import { readPreferenceServerSelector, ServerSelector } from './server_selection';
+import type { MongoOptions, ServerApi } from '../mongo_client';
+import { TypedEventEmitter } from '../mongo_types';
+import { ReadPreference, ReadPreferenceLike } from '../read_preference';
+import {
+  ClientSession,
+  ClientSessionOptions,
+  ServerSessionId,
+  ServerSessionPool
+} from '../sessions';
+import type { Transaction } from '../transactions';
 import {
-  makeStateMachine,
-  eachAsync,
-  ClientMetadata,
   Callback,
+  ClientMetadata,
+  eachAsync,
+  emitWarning,
+  EventEmitterWithState,
   HostAddress,
+  makeStateMachine,
   ns,
-  emitWarning,
-  EventEmitterWithState
+  shuffle
 } from '../utils';
 import {
-  TopologyType,
-  ServerType,
-  ClusterTime,
-  TimerQueue,
   _advanceClusterTime,
-  drainTimerQueue,
   clearAndRemoveTimerFrom,
+  ClusterTime,
+  drainTimerQueue,
+  ServerType,
   STATE_CLOSED,
   STATE_CLOSING,
+  STATE_CONNECTED,
   STATE_CONNECTING,
-  STATE_CONNECTED
+  TimerQueue,
+  TopologyType
 } from './common';
 import {
-  ServerOpeningEvent,
   ServerClosedEvent,
   ServerDescriptionChangedEvent,
-  TopologyOpeningEvent,
+  ServerOpeningEvent,
   TopologyClosedEvent,
-  TopologyDescriptionChangedEvent
+  TopologyDescriptionChangedEvent,
+  TopologyOpeningEvent
 } from './events';
-import type { Document, BSONSerializeOptions } from '../bson';
-import type { MongoCredentials } from '../cmap/auth/mongo_credentials';
-import type { Transaction } from '../transactions';
-import type { CloseOptions } from '../cmap/connection_pool';
-import { DestroyOptions, Connection, ConnectionEvents } from '../cmap/connection';
-import type { MongoOptions, ServerApi } from '../mongo_client';
-import { DEFAULT_OPTIONS } from '../connection_string';
-import { serialize, deserialize } from '../bson';
-import { TypedEventEmitter } from '../mongo_types';
+import { Server, ServerEvents, ServerOptions } from './server';
+import { compareTopologyVersion, ServerDescription } from './server_description';
+import { readPreferenceServerSelector, ServerSelector } from './server_selection';
+import { SrvPoller, SrvPollingEvent } from './srv_polling';
+import { TopologyDescription } from './topology_description';
 
 // Global state
 let globalTopologyCounter = 0;
 
-// events that we relay to the `Topology`
-const SERVER_RELAY_EVENTS = [
-  Server.SERVER_HEARTBEAT_STARTED,
-  Server.SERVER_HEARTBEAT_SUCCEEDED,
-  Server.SERVER_HEARTBEAT_FAILED,
-  Connection.COMMAND_STARTED,
-  Connection.COMMAND_SUCCEEDED,
-  Connection.COMMAND_FAILED,
-  ...CMAP_EVENTS
-];
-
-// all events we listen to from `Server` instances
-const LOCAL_SERVER_EVENTS = [
-  Server.CONNECT,
-  Server.DESCRIPTION_RECEIVED,
-  Server.CLOSED,
-  Server.ENDED
-];
-
 const stateTransition = makeStateMachine({
   [STATE_CLOSED]: [STATE_CLOSED, STATE_CONNECTING],
   [STATE_CONNECTING]: [STATE_CONNECTING, STATE_CLOSING, STATE_CONNECTED, STATE_CLOSED],
@@ -140,6 +136,8 @@ export interface TopologyPrivate {
 
 /** @public */
 export interface TopologyOptions extends BSONSerializeOptions, ServerOptions {
+  srvMaxHosts: number;
+  srvServiceName: string;
   hosts: HostAddress[];
   retryWrites: boolean;
   retryReads: boolean;
@@ -182,8 +180,8 @@ export type TopologyEvents = {
   topologyOpening(event: TopologyOpeningEvent): void;
   topologyDescriptionChanged(event: TopologyDescriptionChangedEvent): void;
   error(error: Error): void;
-  /** TODO(NODE-3273) - remove error @internal */
-  open(error: undefined, topology: Topology): void;
+  /** @internal */
+  open(topology: Topology): void;
   close(): void;
   timeout(): void;
 } & Omit<ServerEvents, 'connect'> &
@@ -205,27 +203,27 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
   _type?: string;
 
   /** @event */
-  static readonly SERVER_OPENING = 'serverOpening' as const;
+  static readonly SERVER_OPENING = SERVER_OPENING;
   /** @event */
-  static readonly SERVER_CLOSED = 'serverClosed' as const;
+  static readonly SERVER_CLOSED = SERVER_CLOSED;
   /** @event */
-  static readonly SERVER_DESCRIPTION_CHANGED = 'serverDescriptionChanged' as const;
+  static readonly SERVER_DESCRIPTION_CHANGED = SERVER_DESCRIPTION_CHANGED;
   /** @event */
-  static readonly TOPOLOGY_OPENING = 'topologyOpening' as const;
+  static readonly TOPOLOGY_OPENING = TOPOLOGY_OPENING;
   /** @event */
-  static readonly TOPOLOGY_CLOSED = 'topologyClosed' as const;
+  static readonly TOPOLOGY_CLOSED = TOPOLOGY_CLOSED;
   /** @event */
-  static readonly TOPOLOGY_DESCRIPTION_CHANGED = 'topologyDescriptionChanged' as const;
+  static readonly TOPOLOGY_DESCRIPTION_CHANGED = TOPOLOGY_DESCRIPTION_CHANGED;
   /** @event */
-  static readonly ERROR = 'error' as const;
+  static readonly ERROR = ERROR;
   /** @event */
-  static readonly OPEN = 'open' as const;
+  static readonly OPEN = OPEN;
   /** @event */
-  static readonly CONNECT = 'connect' as const;
+  static readonly CONNECT = CONNECT;
   /** @event */
-  static readonly CLOSE = 'close' as const;
+  static readonly CLOSE = CLOSE;
   /** @event */
-  static readonly TIMEOUT = 'timeout' as const;
+  static readonly TIMEOUT = TIMEOUT;
 
   /**
    * @internal
@@ -290,8 +288,15 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
     const topologyType = topologyTypeFromOptions(options);
     const topologyId = globalTopologyCounter++;
 
+    const selectedHosts =
+      options.srvMaxHosts == null ||
+      options.srvMaxHosts === 0 ||
+      options.srvMaxHosts >= seedlist.length
+        ? seedlist
+        : shuffle(seedlist, options.srvMaxHosts);
+
     const serverDescriptions = new Map();
-    for (const hostAddress of seedlist) {
+    for (const hostAddress of selectedHosts) {
       serverDescriptions.set(hostAddress.toString(), new ServerDescription(hostAddress));
     }
 
@@ -339,7 +344,9 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
         options.srvPoller ??
         new SrvPoller({
           heartbeatFrequencyMS: this.s.heartbeatFrequencyMS,
-          srvHost: options.srvHost
+          srvHost: options.srvHost,
+          srvMaxHosts: options.srvMaxHosts,
+          srvServiceName: options.srvServiceName
         });
 
       this.on(Topology.TOPOLOGY_DESCRIPTION_CHANGED, this.s.detectShardedTopology);
@@ -363,7 +370,10 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
 
   private detectSrvRecords(ev: SrvPollingEvent) {
     const previousTopologyDescription = this.s.description;
-    this.s.description = this.s.description.updateFromSrvPollingEvent(ev);
+    this.s.description = this.s.description.updateFromSrvPollingEvent(
+      ev,
+      this.s.options.srvMaxHosts
+    );
     if (this.s.description === previousTopologyDescription) {
       // Nothing changed, so return
       return;
@@ -456,8 +466,7 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
           }
 
           stateTransition(this, STATE_CONNECTED);
-          // TODO(NODE-3273) - remove err
-          this.emit(Topology.OPEN, err, this);
+          this.emit(Topology.OPEN, this);
           this.emit(Topology.CONNECT, this);
 
           if (typeof callback === 'function') callback(undefined, this);
@@ -467,8 +476,7 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
       }
 
       stateTransition(this, STATE_CONNECTED);
-      // TODO(NODE-3273) - remove err
-      this.emit(Topology.OPEN, err, this);
+      this.emit(Topology.OPEN, this);
       this.emit(Topology.CONNECT, this);
 
       if (typeof callback === 'function') callback(undefined, this);
@@ -797,6 +805,10 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
     return result;
   }
 
+  get commonWireVersion(): number | undefined {
+    return this.description.commonWireVersion;
+  }
+
   get logicalSessionTimeoutMinutes(): number | undefined {
     return this.description.logicalSessionTimeoutMinutes;
   }
@@ -810,19 +822,6 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
   }
 }
 
-/** @public */
-export const TOPOLOGY_EVENTS = [
-  Topology.SERVER_OPENING,
-  Topology.SERVER_CLOSED,
-  Topology.SERVER_DESCRIPTION_CHANGED,
-  Topology.TOPOLOGY_OPENING,
-  Topology.TOPOLOGY_CLOSED,
-  Topology.TOPOLOGY_DESCRIPTION_CHANGED,
-  Topology.ERROR,
-  Topology.TIMEOUT,
-  Topology.CLOSE
-];
-
 /** Destroys a server, and removes all event listeners from the instance */
 function destroyServer(
   server: Server,

package/src/sdam/topology_description.ts

@@ -1,9 +1,10 @@
-import { ServerDescription } from './server_description';
+import type { Document, ObjectId } from '../bson';
 import * as WIRE_CONSTANTS from '../cmap/wire_protocol/constants';
-import { TopologyType, ServerType } from './common';
-import type { ObjectId, Document } from '../bson';
-import type { SrvPollingEvent } from './srv_polling';
 import { MongoError, MongoRuntimeError } from '../error';
+import { shuffle } from '../utils';
+import { ServerType, TopologyType } from './common';
+import { ServerDescription } from './server_description';
+import type { SrvPollingEvent } from './srv_polling';
 
 // constants related to compatibility checks
 const MIN_SUPPORTED_SERVER_VERSION = WIRE_CONSTANTS.MIN_SUPPORTED_SERVER_VERSION;
@@ -139,23 +140,46 @@ export class TopologyDescription {
    * Returns a new TopologyDescription based on the SrvPollingEvent
    * @internal
    */
-  updateFromSrvPollingEvent(ev: SrvPollingEvent): TopologyDescription {
-    const newAddresses = ev.addresses();
-    const serverDescriptions = new Map(this.servers);
-    for (const address of this.servers.keys()) {
-      if (newAddresses.has(address)) {
-        newAddresses.delete(address);
-      } else {
-        serverDescriptions.delete(address);
+  updateFromSrvPollingEvent(ev: SrvPollingEvent, srvMaxHosts = 0): TopologyDescription {
+    /** The SRV addresses defines the set of addresses we should be using */
+    const incomingHostnames = ev.hostnames();
+    const currentHostnames = new Set(this.servers.keys());
+
+    const hostnamesToAdd = new Set<string>(incomingHostnames);
+    const hostnamesToRemove = new Set<string>();
+    for (const hostname of currentHostnames) {
+      // filter hostnamesToAdd (made from incomingHostnames) down to what is *not* present in currentHostnames
+      hostnamesToAdd.delete(hostname);
+      if (!incomingHostnames.has(hostname)) {
+        // If the SRV Records no longer include this hostname
+        // we have to stop using it
+        hostnamesToRemove.add(hostname);
       }
     }
 
-    if (serverDescriptions.size === this.servers.size && newAddresses.size === 0) {
+    if (hostnamesToAdd.size === 0 && hostnamesToRemove.size === 0) {
+      // No new hosts to add and none to remove
       return this;
     }
 
-    for (const [address, host] of newAddresses) {
-      serverDescriptions.set(address, new ServerDescription(host));
+    const serverDescriptions = new Map(this.servers);
+    for (const removedHost of hostnamesToRemove) {
+      serverDescriptions.delete(removedHost);
+    }
+
+    if (hostnamesToAdd.size > 0) {
+      if (srvMaxHosts === 0) {
+        // Add all!
+        for (const hostToAdd of hostnamesToAdd) {
+          serverDescriptions.set(hostToAdd, new ServerDescription(hostToAdd));
+        }
+      } else if (serverDescriptions.size < srvMaxHosts) {
+        // Add only the amount needed to get us back to srvMaxHosts
+        const selectedHosts = shuffle(hostnamesToAdd, srvMaxHosts - serverDescriptions.size);
+        for (const selectedHostToAdd of selectedHosts) {
+          serverDescriptions.set(selectedHostToAdd, new ServerDescription(selectedHostToAdd));
+        }
+      }
     }
 
     return new TopologyDescription(

package/src/sessions.ts

@@ -1,45 +1,47 @@
-import { PromiseProvider } from './promise_provider';
-import { Binary, Long, Timestamp, Document } from './bson';
-import { ReadPreference } from './read_preference';
-import { isTransactionCommand, TxnState, Transaction, TransactionOptions } from './transactions';
-import { _advanceClusterTime, ClusterTime, TopologyType } from './sdam/common';
+import { Binary, Document, Long, Timestamp } from './bson';
+import type { CommandOptions, Connection } from './cmap/connection';
+import { ConnectionPoolMetrics } from './cmap/metrics';
 import { isSharded } from './cmap/wire_protocol/shared';
+import { PINNED, UNPINNED } from './constants';
+import type { AbstractCursor } from './cursor/abstract_cursor';
 import {
-  MongoError,
-  MongoInvalidArgumentError,
+  AnyError,
+  isRetryableEndTransactionError,
   isRetryableError,
+  MongoAPIError,
   MongoCompatibilityError,
-  MongoNetworkError,
-  MongoWriteConcernError,
   MONGODB_ERROR_CODES,
-  MongoServerError,
   MongoDriverError,
-  MongoAPIError,
-  AnyError,
+  MongoError,
   MongoExpiredSessionError,
+  MongoInvalidArgumentError,
+  MongoNetworkError,
+  MongoRuntimeError,
+  MongoServerError,
   MongoTransactionError,
-  MongoRuntimeError
+  MongoWriteConcernError
 } from './error';
+import type { MongoOptions } from './mongo_client';
+import { TypedEventEmitter } from './mongo_types';
+import { executeOperation } from './operations/execute_operation';
+import { RunAdminCommandOperation } from './operations/run_command';
+import { PromiseProvider } from './promise_provider';
+import { ReadConcernLevel } from './read_concern';
+import { ReadPreference } from './read_preference';
+import { _advanceClusterTime, ClusterTime, TopologyType } from './sdam/common';
+import type { Topology } from './sdam/topology';
+import { isTransactionCommand, Transaction, TransactionOptions, TxnState } from './transactions';
 import {
-  now,
   calculateDurationInMs,
   Callback,
+  commandSupportsReadConcern,
   isPromiseLike,
-  uuidV4,
   maxWireVersion,
-  maybePromise
+  maybePromise,
+  now,
+  uuidV4
 } from './utils';
-import type { Topology } from './sdam/topology';
-import type { MongoOptions } from './mongo_client';
-import { executeOperation } from './operations/execute_operation';
-import { RunAdminCommandOperation } from './operations/run_command';
-import type { AbstractCursor } from './cursor/abstract_cursor';
-import type { CommandOptions } from './cmap/connection';
-import { Connection } from './cmap/connection';
-import { ConnectionPoolMetrics } from './cmap/metrics';
 import type { WriteConcern } from './write_concern';
-import { TypedEventEmitter } from './mongo_types';
-import { ReadConcernLevel } from './read_concern';
 
 const minWireVersionForShardedTransactions = 8;
 
@@ -224,7 +226,7 @@ export class ClientSession extends TypedEventEmitter<ClientSessionEvents> {
 
     this[kPinnedConnection] = conn;
     conn.emit(
-      Connection.PINNED,
+      PINNED,
       this.inTransaction() ? ConnectionPoolMetrics.TXN : ConnectionPoolMetrics.CURSOR
     );
   }
@@ -519,7 +521,7 @@ export function maybeClearPinnedConnection(
     if (options?.error == null || options?.force) {
       loadBalancer.s.pool.checkIn(conn);
       conn.emit(
-        Connection.UNPINNED,
+        UNPINNED,
         session.transaction.state !== TxnState.NO_TRANSACTION
           ? ConnectionPoolMetrics.TXN
           : ConnectionPoolMetrics.CURSOR
@@ -767,7 +769,7 @@ function endTransaction(session: ClientSession, commandName: string, callback: C
         session.unpin();
       }
 
-      if (err && isRetryableError(err as MongoError)) {
+      if (err && isRetryableEndTransactionError(err as MongoError)) {
         // SPEC-1185: apply majority write concern when retrying commitTransaction
         if (command.commitTransaction) {
           // per txns spec, must unpin session in this case
@@ -928,25 +930,6 @@ export class ServerSessionPool {
   }
 }
 
-// TODO: this should be codified in command construction
-// @see https://github.com/mongodb/specifications/blob/master/source/read-write-concern/read-write-concern.rst#read-concern
-export function commandSupportsReadConcern(command: Document, options?: Document): boolean {
-  if (command.aggregate || command.count || command.distinct || command.find || command.geoNear) {
-    return true;
-  }
-
-  if (
-    command.mapReduce &&
-    options &&
-    options.out &&
-    (options.out.inline === 1 || options.out === 'inline')
-  ) {
-    return true;
-  }
-
-  return false;
-}
-
 /**
  * Optionally decorate a command with sessions specific keys
  *

package/src/transactions.ts

@@ -1,10 +1,10 @@
-import { ReadPreference } from './read_preference';
+import type { Document } from './bson';
 import { MongoRuntimeError, MongoTransactionError } from './error';
-import { ReadConcern } from './read_concern';
-import { WriteConcern } from './write_concern';
-import type { Server } from './sdam/server';
 import type { CommandOperationOptions } from './operations/command';
-import type { Document } from './bson';
+import { ReadConcern, ReadConcernLike } from './read_concern';
+import { ReadPreference } from './read_preference';
+import type { Server } from './sdam/server';
+import { WriteConcern } from './write_concern';
 
 /** @internal */
 export const TxnState = Object.freeze({
@@ -63,7 +63,7 @@ const COMMITTED_STATES: Set<TxnState> = new Set([
 export interface TransactionOptions extends CommandOperationOptions {
   // TODO(NODE-3344): These options use the proper class forms of these settings, it should accept the basic enum values too
   /** A default read concern for commands in this transaction */
-  readConcern?: ReadConcern;
+  readConcern?: ReadConcernLike;
   /** A default writeConcern for commands in this transaction */
   writeConcern?: WriteConcern;
   /** A default read preference for commands in this transaction */