mongodb 4.0.0 → 4.1.2

package/src/sdam/topology.ts

@@ -11,7 +11,13 @@ import {
 } from '../sessions';
 import { SrvPoller, SrvPollingEvent } from './srv_polling';
 import { CMAP_EVENTS, ConnectionPoolEvents } from '../cmap/connection_pool';
-import { MongoServerSelectionError, MongoDriverError } from '../error';
+import {
+  MongoServerSelectionError,
+  MongoCompatibilityError,
+  MongoDriverError,
+  MongoTopologyClosedError,
+  MongoRuntimeError
+} from '../error';
 import { readPreferenceServerSelector, ServerSelector } from './server_selection';
 import {
   makeStateMachine,
@@ -28,7 +34,7 @@ import {
   ServerType,
   ClusterTime,
   TimerQueue,
-  resolveClusterTime,
+  _advanceClusterTime,
   drainTimerQueue,
   clearAndRemoveTimerFrom,
   STATE_CLOSED,
@@ -146,6 +152,7 @@ export interface TopologyOptions extends BSONSerializeOptions, ServerOptions {
   srvPoller?: SrvPoller;
   /** Indicates that a client should directly connect to a node without attempting to discover its topology type */
   directConnection: boolean;
+  loadBalanced: boolean;
   metadata: ClientMetadata;
   /** MongoDB server API version */
   serverApi?: ServerApi;
@@ -248,6 +255,7 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
       retryWrites: DEFAULT_OPTIONS.get('retryWrites'),
       serverSelectionTimeoutMS: DEFAULT_OPTIONS.get('serverSelectionTimeoutMS'),
       directConnection: DEFAULT_OPTIONS.get('directConnection'),
+      loadBalanced: DEFAULT_OPTIONS.get('loadBalanced'),
       metadata: DEFAULT_OPTIONS.get('metadata'),
       monitorCommands: DEFAULT_OPTIONS.get('monitorCommands'),
       tls: DEFAULT_OPTIONS.get('tls'),
@@ -274,7 +282,8 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
       } else if (seed instanceof HostAddress) {
         seedlist.push(seed);
       } else {
-        throw new MongoDriverError(`Topology cannot be constructed from ${JSON.stringify(seed)}`);
+        // FIXME(NODE-3483): May need to be a MongoParseError
+        throw new MongoRuntimeError(`Topology cannot be constructed from ${JSON.stringify(seed)}`);
       }
     }
 
@@ -325,7 +334,7 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
       detectSrvRecords: ev => this.detectSrvRecords(ev)
     };
 
-    if (options.srvHost) {
+    if (options.srvHost && !options.loadBalanced) {
       this.s.srvPoller =
         options.srvPoller ??
         new SrvPoller({
@@ -379,6 +388,10 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
     return this.s.description;
   }
 
+  get loadBalanced(): boolean {
+    return this.s.options.loadBalanced;
+  }
+
   get capabilities(): ServerCapabilities {
     return new ServerCapabilities(this.lastIsMaster());
   }
@@ -411,7 +424,19 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
     );
 
     // connect all known servers, then attempt server selection to connect
-    connectServers(this, Array.from(this.s.description.servers.values()));
+    const serverDescriptions = Array.from(this.s.description.servers.values());
+    connectServers(this, serverDescriptions);
+
+    // In load balancer mode we need to fake a server description getting
+    // emitted from the monitor, since the monitor doesn't exist.
+    if (this.s.options.loadBalanced) {
+      for (const description of serverDescriptions) {
+        const newDescription = new ServerDescription(description.hostAddress, undefined, {
+          loadBalanced: this.s.options.loadBalanced
+        });
+        this.serverUpdateHandler(newDescription);
+      }
+    }
 
     const readPreference = options.readPreference ?? ReadPreference.primary;
     this.selectServer(readPreferenceServerSelector(readPreference), options, (err, server) => {
@@ -472,7 +497,7 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
 
     stateTransition(this, STATE_CLOSING);
 
-    drainWaitQueue(this[kWaitQueue], new MongoDriverError('Topology closed'));
+    drainWaitQueue(this[kWaitQueue], new MongoTopologyClosedError());
     drainTimerQueue(this.s.connectionTimers);
 
     if (this.s.srvPoller) {
@@ -482,28 +507,30 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
 
     this.removeListener(Topology.TOPOLOGY_DESCRIPTION_CHANGED, this.s.detectShardedTopology);
 
-    for (const session of this.s.sessions) {
-      session.endSession();
-    }
-
-    this.s.sessionPool.endAllPooledSessions(() => {
-      eachAsync(
-        Array.from(this.s.servers.values()),
-        (server, cb) => destroyServer(server, this, options, cb),
-        err => {
-          this.s.servers.clear();
-
-          // emit an event for close
-          this.emit(Topology.TOPOLOGY_CLOSED, new TopologyClosedEvent(this.s.id));
-
-          stateTransition(this, STATE_CLOSED);
-
-          if (typeof callback === 'function') {
-            callback(err);
-          }
-        }
-      );
-    });
+    eachAsync(
+      Array.from(this.s.sessions.values()),
+      (session, cb) => session.endSession(cb),
+      () => {
+        this.s.sessionPool.endAllPooledSessions(() => {
+          eachAsync(
+            Array.from(this.s.servers.values()),
+            (server, cb) => destroyServer(server, this, options, cb),
+            err => {
+              this.s.servers.clear();
+
+              // emit an event for close
+              this.emit(Topology.TOPOLOGY_CLOSED, new TopologyClosedEvent(this.s.id));
+
+              stateTransition(this, STATE_CLOSED);
+
+              if (typeof callback === 'function') {
+                callback(err);
+              }
+            }
+          );
+        });
+      }
+    );
   }
 
   /**
@@ -610,7 +637,7 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
    * @returns Whether sessions are supported on the current topology
    */
   hasSessionSupport(): boolean {
-    return this.description.logicalSessionTimeoutMinutes != null;
+    return this.loadBalanced || this.description.logicalSessionTimeoutMinutes != null;
   }
 
   /** Start a logical session */
@@ -680,7 +707,7 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
     // value of the clusterTime embedded field."
     const clusterTime = serverDescription.$clusterTime;
     if (clusterTime) {
-      resolveClusterTime(this, clusterTime);
+      _advanceClusterTime(this, clusterTime);
     }
 
     // If we already know all the information contained in this updated description, then
@@ -692,7 +719,7 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
     // first update the TopologyDescription
     this.s.description = this.s.description.update(serverDescription);
     if (this.s.description.compatibilityError) {
-      this.emit(Topology.ERROR, new MongoDriverError(this.s.description.compatibilityError));
+      this.emit(Topology.ERROR, new MongoCompatibilityError(this.s.description.compatibilityError));
       return;
     }
 
@@ -749,8 +776,11 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
     return this.s.state === STATE_CLOSED;
   }
 
+  /**
+   * @deprecated This function is deprecated and will be removed in the next major version.
+   */
   unref(): void {
-    emitWarning('not implemented: `unref`');
+    emitWarning('`unref` is a noop and will be removed in the next major version');
   }
 
   // NOTE: There are many places in code where we explicitly check the last isMaster
@@ -830,6 +860,10 @@ function topologyTypeFromOptions(options?: TopologyOptions) {
     return TopologyType.ReplicaSetNoPrimary;
   }
 
+  if (options?.loadBalanced) {
+    return TopologyType.LoadBalanced;
+  }
+
   return TopologyType.Unknown;
 }
 
@@ -954,10 +988,7 @@ function drainWaitQueue(queue: Denque<ServerSelectionRequest>, err?: MongoDriver
 
 function processWaitQueue(topology: Topology) {
   if (topology.s.state === STATE_CLOSED) {
-    drainWaitQueue(
-      topology[kWaitQueue],
-      new MongoDriverError('Topology is closed, please connect')
-    );
+    drainWaitQueue(topology[kWaitQueue], new MongoTopologyClosedError());
     return;
   }
 

package/src/sdam/topology_description.ts

@@ -3,7 +3,7 @@ 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 { MongoDriverError, MongoError } from '../error';
+import { MongoError, MongoRuntimeError } from '../error';
 
 // constants related to compatibility checks
 const MIN_SUPPORTED_SERVER_VERSION = WIRE_CONSTANTS.MIN_SUPPORTED_SERVER_VERSION;
@@ -85,7 +85,13 @@ export class TopologyDescription {
 
     // determine server compatibility
     for (const serverDescription of this.servers.values()) {
-      if (serverDescription.type === ServerType.Unknown) continue;
+      // Load balancer mode is always compatible.
+      if (
+        serverDescription.type === ServerType.Unknown ||
+        serverDescription.type === ServerType.LoadBalancer
+      ) {
+        continue;
+      }
 
       if (serverDescription.minWireVersion > MAX_SUPPORTED_WIRE_VERSION) {
         this.compatible = false;
@@ -113,7 +119,7 @@ export class TopologyDescription {
           break;
         }
 
-        if (this.logicalSessionTimeoutMinutes === undefined) {
+        if (this.logicalSessionTimeoutMinutes == null) {
           // First server with a non null logicalSessionsTimeout
           this.logicalSessionTimeoutMinutes = server.logicalSessionTimeoutMinutes;
           continue;
@@ -431,7 +437,8 @@ function updateRsWithPrimaryFromMember(
   setName?: string
 ): TopologyType {
   if (setName == null) {
-    throw new MongoDriverError('setName is required');
+    // TODO(NODE-3483): should be an appropriate runtime error
+    throw new MongoRuntimeError('Argument "setName" is required if connected to a replica set');
   }
 
   if (