mongodb 4.1.4 → 4.3.0

package/src/read_preference.ts

@@ -1,7 +1,7 @@
-import type { TagSet } from './sdam/server_description';
 import type { Document } from './bson';
-import type { ClientSession } from './sessions';
 import { MongoInvalidArgumentError } from './error';
+import type { TagSet } from './sdam/server_description';
+import type { ClientSession } from './sessions';
 
 /** @public */
 export type ReadPreferenceLike = ReadPreference | ReadPreferenceMode;
@@ -156,7 +156,10 @@ export class ReadPreference {
     }
 
     if (typeof readPreference === 'string') {
-      return new ReadPreference(readPreference as ReadPreferenceMode, readPreferenceTags);
+      return new ReadPreference(readPreference as ReadPreferenceMode, readPreferenceTags, {
+        maxStalenessSeconds: options.maxStalenessSeconds,
+        hedge: options.hedge
+      });
     } else if (!(readPreference instanceof ReadPreference) && typeof readPreference === 'object') {
       const mode = readPreference.mode || readPreference.preference;
       if (mode && typeof mode === 'string') {
@@ -229,19 +232,27 @@ export class ReadPreference {
   }
 
   /**
-   * Indicates that this readPreference needs the "slaveOk" bit when sent over the wire
-   *
+   * Indicates that this readPreference needs the "secondaryOk" bit when sent over the wire
+   * @deprecated Use secondaryOk instead
    * @see https://docs.mongodb.com/manual/reference/mongodb-wire-protocol/#op-query
    */
   slaveOk(): boolean {
-    const NEEDS_SLAVEOK = new Set<string>([
+    return this.secondaryOk();
+  }
+
+  /**
+   * Indicates that this readPreference needs the "SecondaryOk" bit when sent over the wire
+   * @see https://docs.mongodb.com/manual/reference/mongodb-wire-protocol/#op-query
+   */
+  secondaryOk(): boolean {
+    const NEEDS_SECONDARYOK = new Set<string>([
       ReadPreference.PRIMARY_PREFERRED,
       ReadPreference.SECONDARY,
       ReadPreference.SECONDARY_PREFERRED,
       ReadPreference.NEAREST
     ]);
 
-    return NEEDS_SLAVEOK.has(this.mode);
+    return NEEDS_SECONDARYOK.has(this.mode);
   }
 
   /**

package/src/sdam/common.ts

@@ -1,6 +1,6 @@
-import type { Timestamp, Binary, Long } from '../bson';
-import type { Topology } from './topology';
+import type { Binary, Long, Timestamp } from '../bson';
 import type { ClientSession } from '../sessions';
+import type { Topology } from './topology';
 
 // shared state names
 export const STATE_CLOSING = 'closing';

package/src/sdam/events.ts

@@ -1,6 +1,6 @@
+import type { Document } from '../bson';
 import type { ServerDescription } from './server_description';
 import type { TopologyDescription } from './topology_description';
-import type { Document } from '../bson';
 
 /**
  * Emitted when server description changes, but does NOT include changes to the RTT.

package/src/sdam/monitor.ts

@@ -1,26 +1,25 @@
-import { ServerType, STATE_CLOSED, STATE_CLOSING } from './common';
+import { Document, Long } from '../bson';
+import { connect } from '../cmap/connect';
+import { Connection, ConnectionOptions } from '../cmap/connection';
+import { AnyError, MongoNetworkError } from '../error';
+import { CancellationToken, TypedEventEmitter } from '../mongo_types';
+import type { Callback, InterruptibleAsyncInterval } from '../utils';
 import {
-  now,
-  makeStateMachine,
   calculateDurationInMs,
+  EventEmitterWithState,
   makeInterruptibleAsyncInterval,
-  ns,
-  EventEmitterWithState
+  makeStateMachine,
+  now,
+  ns
 } from '../utils';
-import { connect } from '../cmap/connect';
-import { Connection, ConnectionOptions } from '../cmap/connection';
-import { MongoNetworkError, AnyError } from '../error';
-import { Long, Document } from '../bson';
+import { ServerType, STATE_CLOSED, STATE_CLOSING } from './common';
 import {
+  ServerHeartbeatFailedEvent,
   ServerHeartbeatStartedEvent,
-  ServerHeartbeatSucceededEvent,
-  ServerHeartbeatFailedEvent
+  ServerHeartbeatSucceededEvent
 } from './events';
-
 import { Server } from './server';
-import type { InterruptibleAsyncInterval, Callback } from '../utils';
 import type { TopologyVersion } from './server_description';
-import { CancellationToken, TypedEventEmitter } from '../mongo_types';
 
 /** @internal */
 const kServer = Symbol('server');

package/src/sdam/server.ts

@@ -1,62 +1,72 @@
-import { Logger } from '../logger';
+import type { Document, Long } from '../bson';
+import {
+  CommandOptions,
+  Connection,
+  DestroyOptions,
+  GetMoreOptions,
+  QueryOptions
+} from '../cmap/connection';
 import {
   ConnectionPool,
-  ConnectionPoolOptions,
-  CMAP_EVENTS,
-  ConnectionPoolEvents
+  ConnectionPoolEvents,
+  ConnectionPoolOptions
 } from '../cmap/connection_pool';
-import { ServerDescription, compareTopologyVersion } from './server_description';
-import { Monitor, MonitorOptions } from './monitor';
+import {
+  APM_EVENTS,
+  CLOSED,
+  CMAP_EVENTS,
+  CONNECT,
+  DESCRIPTION_RECEIVED,
+  ENDED,
+  HEARTBEAT_EVENTS,
+  SERVER_HEARTBEAT_FAILED,
+  SERVER_HEARTBEAT_STARTED,
+  SERVER_HEARTBEAT_SUCCEEDED
+} from '../constants';
+import type { AutoEncrypter } from '../deps';
+import {
+  isNetworkErrorBeforeHandshake,
+  isNodeShuttingDownError,
+  isRetryableWriteError,
+  isSDAMUnrecoverableError,
+  MongoCompatibilityError,
+  MongoError,
+  MongoInvalidArgumentError,
+  MongoNetworkError,
+  MongoNetworkTimeoutError,
+  MongoServerClosedError
+} from '../error';
+import { Logger } from '../logger';
+import type { ServerApi } from '../mongo_client';
+import { TypedEventEmitter } from '../mongo_types';
+import type { ClientSession } from '../sessions';
 import { isTransactionCommand } from '../transactions';
 import {
+  Callback,
+  CallbackWithType,
   collationNotSupported,
+  EventEmitterWithState,
   makeStateMachine,
   maxWireVersion,
-  Callback,
-  CallbackWithType,
   MongoDBNamespace,
-  EventEmitterWithState
+  supportsRetryableWrites
 } from '../utils';
 import {
+  ClusterTime,
   STATE_CLOSED,
   STATE_CLOSING,
-  STATE_CONNECTING,
   STATE_CONNECTED,
-  ClusterTime,
+  STATE_CONNECTING,
   TopologyType
 } from './common';
-import {
-  MongoError,
-  MongoNetworkError,
-  MongoNetworkTimeoutError,
-  isSDAMUnrecoverableError,
-  isRetryableWriteError,
-  isNodeShuttingDownError,
-  isNetworkErrorBeforeHandshake,
-  MongoCompatibilityError,
-  MongoInvalidArgumentError,
-  MongoServerClosedError
-} from '../error';
-import {
-  Connection,
-  DestroyOptions,
-  QueryOptions,
-  GetMoreOptions,
-  CommandOptions,
-  APM_EVENTS
-} from '../cmap/connection';
-import type { Topology } from './topology';
 import type {
   ServerHeartbeatFailedEvent,
   ServerHeartbeatStartedEvent,
   ServerHeartbeatSucceededEvent
 } from './events';
-import type { ClientSession } from '../sessions';
-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';
+import { Monitor, MonitorOptions } from './monitor';
+import { compareTopologyVersion, ServerDescription } from './server_description';
+import type { Topology } from './topology';
 
 const stateTransition = makeStateMachine({
   [STATE_CLOSED]: [STATE_CLOSED, STATE_CONNECTING],
@@ -108,24 +118,23 @@ export class Server extends TypedEventEmitter<ServerEvents> {
   /** @internal */
   s: ServerPrivate;
   serverApi?: ServerApi;
-  clusterTime?: ClusterTime;
   ismaster?: Document;
   [kMonitor]: Monitor;
 
   /** @event */
-  static readonly SERVER_HEARTBEAT_STARTED = 'serverHeartbeatStarted' as const;
+  static readonly SERVER_HEARTBEAT_STARTED = SERVER_HEARTBEAT_STARTED;
   /** @event */
-  static readonly SERVER_HEARTBEAT_SUCCEEDED = 'serverHeartbeatSucceeded' as const;
+  static readonly SERVER_HEARTBEAT_SUCCEEDED = SERVER_HEARTBEAT_SUCCEEDED;
   /** @event */
-  static readonly SERVER_HEARTBEAT_FAILED = 'serverHeartbeatFailed' as const;
+  static readonly SERVER_HEARTBEAT_FAILED = SERVER_HEARTBEAT_FAILED;
   /** @event */
-  static readonly CONNECT = 'connect' as const;
+  static readonly CONNECT = CONNECT;
   /** @event */
-  static readonly DESCRIPTION_RECEIVED = 'descriptionReceived' as const;
+  static readonly DESCRIPTION_RECEIVED = DESCRIPTION_RECEIVED;
   /** @event */
-  static readonly CLOSED = 'closed' as const;
+  static readonly CLOSED = CLOSED;
   /** @event */
-  static readonly ENDED = 'ended' as const;
+  static readonly ENDED = ENDED;
 
   /**
    * Create a server
@@ -184,6 +193,14 @@ export class Server extends TypedEventEmitter<ServerEvents> {
     });
   }
 
+  get clusterTime(): ClusterTime | undefined {
+    return this.s.topology.clusterTime;
+  }
+
+  set clusterTime(clusterTime: ClusterTime | undefined) {
+    this.s.topology.clusterTime = clusterTime;
+  }
+
   get description(): ServerDescription {
     return this.s.description;
   }
@@ -299,6 +316,14 @@ export class Server extends TypedEventEmitter<ServerEvents> {
     // Clone the options
     const finalOptions = Object.assign({}, options, { wireProtocolCommand: false });
 
+    // There are cases where we need to flag the read preference not to get sent in
+    // the command, such as pre-5.0 servers attempting to perform an aggregate write
+    // with a non-primary read preference. In this case the effective read preference
+    // (primary) is not the same as the provided and must be removed completely.
+    if (finalOptions.omitReadPreference) {
+      delete finalOptions.readPreference;
+    }
+
     // error if collation not supported
     if (collationNotSupported(this, cmd)) {
       callback(new MongoCompatibilityError(`Server ${this.name} does not support collation`));
@@ -445,21 +470,6 @@ export class Server extends TypedEventEmitter<ServerEvents> {
   }
 }
 
-export const HEARTBEAT_EVENTS = [
-  Server.SERVER_HEARTBEAT_STARTED,
-  Server.SERVER_HEARTBEAT_SUCCEEDED,
-  Server.SERVER_HEARTBEAT_FAILED
-];
-
-Object.defineProperty(Server.prototype, 'clusterTime', {
-  get() {
-    return this.s.topology.clusterTime;
-  },
-  set(clusterTime: ClusterTime) {
-    this.s.topology.clusterTime = clusterTime;
-  }
-});
-
 function calculateRoundTripTime(oldRtt: number, duration: number): number {
   if (oldRtt === -1) {
     return duration;

package/src/sdam/server_description.ts

@@ -1,8 +1,8 @@
-import { arrayStrictEqual, errorStrictEqual, now, HostAddress } from '../utils';
-import { ServerType } from './common';
-import { ObjectId, Long, Document } from '../bson';
-import type { ClusterTime } from './common';
+import { Document, Long, ObjectId } from '../bson';
 import type { MongoError } from '../error';
+import { arrayStrictEqual, errorStrictEqual, HostAddress, now } from '../utils';
+import type { ClusterTime } from './common';
+import { ServerType } from './common';
 
 const WRITABLE_SERVER_TYPES = new Set<ServerType>([
   ServerType.RSPrimary,

package/src/sdam/server_selection.ts

@@ -1,13 +1,16 @@
-import { ServerType, TopologyType } from './common';
-import { ReadPreference } from '../read_preference';
 import { MongoCompatibilityError, MongoInvalidArgumentError } from '../error';
-import type { TopologyDescription } from './topology_description';
+import { ReadPreference } from '../read_preference';
+import { ServerType, TopologyType } from './common';
 import type { ServerDescription, TagSet } from './server_description';
+import type { TopologyDescription } from './topology_description';
 
 // max staleness constants
 const IDLE_WRITE_PERIOD = 10000;
 const SMALLEST_MAX_STALENESS_SECONDS = 90;
 
+//  Minimum version to try writes on secondaries.
+export const MIN_SECONDARY_WRITE_WIRE_VERSION = 13;
+
 /** @public */
 export type ServerSelector = (
   topologyDescription: TopologyDescription,
@@ -28,6 +31,46 @@ export function writableServerSelector(): ServerSelector {
     );
 }
 
+/**
+ * The purpose of this selector is to select the same server, only
+ * if it is in a state that it can have commands sent to it.
+ */
+export function sameServerSelector(description?: ServerDescription): ServerSelector {
+  return (
+    topologyDescription: TopologyDescription,
+    servers: ServerDescription[]
+  ): ServerDescription[] => {
+    if (!description) return [];
+    // Filter the servers to match the provided description only if
+    // the type is not unknown.
+    return servers.filter(sd => {
+      return sd.address === description.address && sd.type !== ServerType.Unknown;
+    });
+  };
+}
+
+/**
+ * Returns a server selector that uses a read preference to select a
+ * server potentially for a write on a secondary.
+ */
+export function secondaryWritableServerSelector(
+  wireVersion?: number,
+  readPreference?: ReadPreference
+): ServerSelector {
+  // If server version < 5.0, read preference always primary.
+  // If server version >= 5.0...
+  // - If read preference is supplied, use that.
+  // - If no read preference is supplied, use primary.
+  if (
+    !readPreference ||
+    !wireVersion ||
+    (wireVersion && wireVersion < MIN_SECONDARY_WRITE_WIRE_VERSION)
+  ) {
+    return readPreferenceServerSelector(ReadPreference.primary);
+  }
+  return readPreferenceServerSelector(readPreference);
+}
+
 /**
  * Reduces the passed in array of servers by the rules of the "Max Staleness" specification
  * found here: https://github.com/mongodb/specifications/blob/master/source/max-staleness/max-staleness.rst

package/src/sdam/srv_polling.ts

@@ -1,8 +1,9 @@
 import * as dns from 'dns';
+
+import { MongoRuntimeError } from '../error';
 import { Logger, LoggerOptions } from '../logger';
-import { HostAddress } from '../utils';
 import { TypedEventEmitter } from '../mongo_types';
-import { MongoRuntimeError } from '../error';
+import { HostAddress } from '../utils';
 
 /**
  * Determines whether a provided address matches the provided parent domain in order
@@ -29,18 +30,15 @@ export class SrvPollingEvent {
     this.srvRecords = srvRecords;
   }
 
-  addresses(): Map<string, HostAddress> {
-    return new Map(
-      this.srvRecords.map(record => {
-        const host = new HostAddress(`${record.name}:${record.port}`);
-        return [host.toString(), host];
-      })
-    );
+  hostnames(): Set<string> {
+    return new Set(this.srvRecords.map(r => HostAddress.fromSrvRecord(r).toString()));
   }
 }
 
 /** @internal */
 export interface SrvPollerOptions extends LoggerOptions {
+  srvServiceName: string;
+  srvMaxHosts: number;
   srvHost: string;
   heartbeatFrequencyMS: number;
 }
@@ -58,6 +56,8 @@ export class SrvPoller extends TypedEventEmitter<SrvPollerEvents> {
   logger: Logger;
   haMode: boolean;
   generation: number;
+  srvMaxHosts: number;
+  srvServiceName: string;
   _timeout?: NodeJS.Timeout;
 
   /** @event */
@@ -71,8 +71,10 @@ export class SrvPoller extends TypedEventEmitter<SrvPollerEvents> {
     }
 
     this.srvHost = options.srvHost;
+    this.srvMaxHosts = options.srvMaxHosts ?? 0;
+    this.srvServiceName = options.srvServiceName ?? 'mongodb';
     this.rescanSrvIntervalMS = 60000;
-    this.heartbeatFrequencyMS = options.heartbeatFrequencyMS || 10000;
+    this.heartbeatFrequencyMS = options.heartbeatFrequencyMS ?? 10000;
     this.logger = new Logger('srvPoller', options);
 
     this.haMode = false;
@@ -82,7 +84,7 @@ export class SrvPoller extends TypedEventEmitter<SrvPollerEvents> {
   }
 
   get srvAddress(): string {
-    return `_mongodb._tcp.${this.srvHost}`;
+    return `_${this.srvServiceName}._tcp.${this.srvHost}`;
   }
 
   get intervalMS(): number {
@@ -143,13 +145,13 @@ export class SrvPoller extends TypedEventEmitter<SrvPollerEvents> {
       }
 
       const finalAddresses: dns.SrvRecord[] = [];
-      srvRecords.forEach((record: dns.SrvRecord) => {
+      for (const record of srvRecords) {
         if (matchesParentDomain(record.name, this.srvHost)) {
           finalAddresses.push(record);
         } else {
           this.parentDomainMismatch(record);
         }
-      });
+      }
 
       if (!finalAddresses.length) {
         this.failure('No valid addresses found at host');