mongodb 4.2.1 → 4.4.0

package/src/sdam/monitor.ts

@@ -1,26 +1,26 @@
-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 { LEGACY_HELLO_COMMAND } from '../constants';
+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');
@@ -234,7 +234,7 @@ function checkServer(monitor: Monitor, callback: Callback<Document>) {
     const isAwaitable = topologyVersion != null;
 
     const cmd = {
-      [serverApi?.version || helloOk ? 'hello' : 'ismaster']: true,
+      [serverApi?.version || helloOk ? 'hello' : LEGACY_HELLO_COMMAND]: true,
       ...(isAwaitable && topologyVersion
         ? { maxAwaitTimeMS, topologyVersion: makeTopologyVersion(topologyVersion) }
         : {})
@@ -257,14 +257,15 @@ function checkServer(monitor: Monitor, callback: Callback<Document>) {
       );
     }
 
-    connection.command(ns('admin.$cmd'), cmd, options, (err, isMaster) => {
+    connection.command(ns('admin.$cmd'), cmd, options, (err, hello) => {
       if (err) {
         failureHandler(err);
         return;
       }
-      if ('isWritablePrimary' in isMaster) {
-        // Provide pre-hello-style response document.
-        isMaster.ismaster = isMaster.isWritablePrimary;
+
+      if (!('isWritablePrimary' in hello)) {
+        // Provide hello-style response document.
+        hello.isWritablePrimary = hello[LEGACY_HELLO_COMMAND];
       }
 
       const rttPinger = monitor[kRTTPinger];
@@ -273,12 +274,12 @@ function checkServer(monitor: Monitor, callback: Callback<Document>) {
 
       monitor.emit(
         Server.SERVER_HEARTBEAT_SUCCEEDED,
-        new ServerHeartbeatSucceededEvent(monitor.address, duration, isMaster)
+        new ServerHeartbeatSucceededEvent(monitor.address, duration, hello)
       );
 
       // 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) {
+      if (isAwaitable && hello.topologyVersion) {
         monitor.emit(
           Server.SERVER_HEARTBEAT_STARTED,
           new ServerHeartbeatStartedEvent(monitor.address)
@@ -288,14 +289,14 @@ function checkServer(monitor: Monitor, callback: Callback<Document>) {
         monitor[kRTTPinger]?.close();
         monitor[kRTTPinger] = undefined;
 
-        callback(undefined, isMaster);
+        callback(undefined, hello);
       }
     });
 
     return;
   }
 
-  // connecting does an implicit `ismaster`
+  // connecting does an implicit `hello`
   connect(monitor.connectOptions, (err, conn) => {
     if (err) {
       monitor[kConnection] = undefined;
@@ -318,14 +319,10 @@ function checkServer(monitor: Monitor, callback: Callback<Document>) {
       monitor[kConnection] = conn;
       monitor.emit(
         Server.SERVER_HEARTBEAT_SUCCEEDED,
-        new ServerHeartbeatSucceededEvent(
-          monitor.address,
-          calculateDurationInMs(start),
-          conn.ismaster
-        )
+        new ServerHeartbeatSucceededEvent(monitor.address, calculateDurationInMs(start), conn.hello)
       );
 
-      callback(undefined, conn.ismaster);
+      callback(undefined, conn.hello);
     }
   });
 }
@@ -341,7 +338,7 @@ function monitorServer(monitor: Monitor) {
       callback();
     }
 
-    checkServer(monitor, (err, isMaster) => {
+    checkServer(monitor, (err, hello) => {
       if (err) {
         // otherwise an error occurred on initial discovery, also bail
         if (monitor[kServer].description.type === ServerType.Unknown) {
@@ -351,7 +348,7 @@ function monitorServer(monitor: Monitor) {
       }
 
       // if the check indicates streaming is supported, immediately reschedule monitoring
-      if (isMaster && isMaster.topologyVersion) {
+      if (hello && hello.topologyVersion) {
         setTimeout(() => {
           if (!isInCloseState(monitor)) {
             monitor[kMonitorId]?.wake();
@@ -453,7 +450,7 @@ function measureRoundTripTime(rttPinger: RTTPinger, options: RTTPingerOptions) {
     return;
   }
 
-  connection.command(ns('admin.$cmd'), { ismaster: 1 }, undefined, err => {
+  connection.command(ns('admin.$cmd'), { [LEGACY_HELLO_COMMAND]: 1 }, undefined, err => {
     if (err) {
       rttPinger[kConnection] = undefined;
       rttPinger[kRoundTripTime] = 0;

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;
+  hello?: 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;
   }
@@ -453,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,
@@ -44,7 +44,7 @@ export interface ServerDescriptionOptions {
 }
 
 /**
- * The client's view of a single server, based on the most recent ismaster outcome.
+ * The client's view of a single server, based on the most recent hello outcome.
  *
  * Internal type, not meant to be directly instantiated
  * @public
@@ -81,13 +81,9 @@ export class ServerDescription {
    * @internal
    *
    * @param address - The address of the server
-   * @param ismaster - An optional ismaster response for this server
+   * @param hello - An optional hello response for this server
    */
-  constructor(
-    address: HostAddress | string,
-    ismaster?: Document,
-    options?: ServerDescriptionOptions
-  ) {
+  constructor(address: HostAddress | string, hello?: Document, options?: ServerDescriptionOptions) {
     if (typeof address === 'string') {
       this._hostAddress = new HostAddress(address);
       this.address = this._hostAddress.toString();
@@ -95,53 +91,53 @@ export class ServerDescription {
       this._hostAddress = address;
       this.address = this._hostAddress.toString();
     }
-    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()) ?? [];
-    this.tags = ismaster?.tags ?? {};
-    this.minWireVersion = ismaster?.minWireVersion ?? 0;
-    this.maxWireVersion = ismaster?.maxWireVersion ?? 0;
+    this.type = parseServerType(hello, options);
+    this.hosts = hello?.hosts?.map((host: string) => host.toLowerCase()) ?? [];
+    this.passives = hello?.passives?.map((host: string) => host.toLowerCase()) ?? [];
+    this.arbiters = hello?.arbiters?.map((host: string) => host.toLowerCase()) ?? [];
+    this.tags = hello?.tags ?? {};
+    this.minWireVersion = hello?.minWireVersion ?? 0;
+    this.maxWireVersion = hello?.maxWireVersion ?? 0;
     this.roundTripTime = options?.roundTripTime ?? -1;
     this.lastUpdateTime = now();
-    this.lastWriteDate = ismaster?.lastWrite?.lastWriteDate ?? 0;
+    this.lastWriteDate = hello?.lastWrite?.lastWriteDate ?? 0;
 
     if (options?.topologyVersion) {
       this.topologyVersion = options.topologyVersion;
-    } else if (ismaster?.topologyVersion) {
-      this.topologyVersion = ismaster.topologyVersion;
+    } else if (hello?.topologyVersion) {
+      this.topologyVersion = hello.topologyVersion;
     }
 
     if (options?.error) {
       this.error = options.error;
     }
 
-    if (ismaster?.primary) {
-      this.primary = ismaster.primary;
+    if (hello?.primary) {
+      this.primary = hello.primary;
     }
 
-    if (ismaster?.me) {
-      this.me = ismaster.me.toLowerCase();
+    if (hello?.me) {
+      this.me = hello.me.toLowerCase();
     }
 
-    if (ismaster?.setName) {
-      this.setName = ismaster.setName;
+    if (hello?.setName) {
+      this.setName = hello.setName;
     }
 
-    if (ismaster?.setVersion) {
-      this.setVersion = ismaster.setVersion;
+    if (hello?.setVersion) {
+      this.setVersion = hello.setVersion;
     }
 
-    if (ismaster?.electionId) {
-      this.electionId = ismaster.electionId;
+    if (hello?.electionId) {
+      this.electionId = hello.electionId;
     }
 
-    if (ismaster?.logicalSessionTimeoutMinutes) {
-      this.logicalSessionTimeoutMinutes = ismaster.logicalSessionTimeoutMinutes;
+    if (hello?.logicalSessionTimeoutMinutes) {
+      this.logicalSessionTimeoutMinutes = hello.logicalSessionTimeoutMinutes;
     }
 
-    if (ismaster?.$clusterTime) {
-      this.$clusterTime = ismaster.$clusterTime;
+    if (hello?.$clusterTime) {
+      this.$clusterTime = hello.$clusterTime;
     }
   }
 
@@ -210,35 +206,32 @@ export class ServerDescription {
   }
 }
 
-// Parses an `ismaster` message and determines the server type
-export function parseServerType(
-  ismaster?: Document,
-  options?: ServerDescriptionOptions
-): ServerType {
+// Parses a `hello` message and determines the server type
+export function parseServerType(hello?: Document, options?: ServerDescriptionOptions): ServerType {
   if (options?.loadBalanced) {
     return ServerType.LoadBalancer;
   }
 
-  if (!ismaster || !ismaster.ok) {
+  if (!hello || !hello.ok) {
     return ServerType.Unknown;
   }
 
-  if (ismaster.isreplicaset) {
+  if (hello.isreplicaset) {
     return ServerType.RSGhost;
   }
 
-  if (ismaster.msg && ismaster.msg === 'isdbgrid') {
+  if (hello.msg && hello.msg === 'isdbgrid') {
     return ServerType.Mongos;
   }
 
-  if (ismaster.setName) {
-    if (ismaster.hidden) {
+  if (hello.setName) {
+    if (hello.hidden) {
       return ServerType.RSOther;
-    } else if (ismaster.ismaster || ismaster.isWritablePrimary) {
+    } else if (hello.isWritablePrimary) {
       return ServerType.RSPrimary;
-    } else if (ismaster.secondary) {
+    } else if (hello.secondary) {
       return ServerType.RSSecondary;
-    } else if (ismaster.arbiterOnly) {
+    } else if (hello.arbiterOnly) {
       return ServerType.RSArbiter;
     } else {
       return ServerType.RSOther;

package/src/sdam/server_selection.ts

@@ -1,8 +1,8 @@
-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;

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