mongodb 6.5.0 → 6.6.0-dev.20240504.sha.2609953

package/src/sdam/topology.ts

@@ -1,5 +1,3 @@
-import { promisify } from 'util';
-
 import type { BSONSerializeOptions, Document } from '../bson';
 import type { MongoCredentials } from '../cmap/auth/mongo_credentials';
 import type { ConnectionEvents } from '../cmap/connection';
@@ -35,6 +33,7 @@ import { MongoLoggableComponent, type MongoLogger, SeverityLevel } from '../mong
 import { TypedEventEmitter } from '../mongo_types';
 import { ReadPreference, type ReadPreferenceLike } from '../read_preference';
 import type { ClientSession } from '../sessions';
+import { Timeout, TimeoutError } from '../timeout';
 import type { Transaction } from '../transactions';
 import {
   type Callback,
@@ -44,8 +43,8 @@ import {
   makeStateMachine,
   now,
   ns,
-  shuffle,
-  TimeoutController
+  promiseWithResolvers,
+  shuffle
 } from '../utils';
 import {
   _advanceClusterTime,
@@ -105,9 +104,10 @@ export interface ServerSelectionRequest {
   mongoLogger: MongoLogger | undefined;
   transaction?: Transaction;
   startTime: number;
-  callback: ServerSelectionCallback;
+  resolve: (server: Server) => void;
+  reject: (error: MongoError) => void;
   [kCancelled]?: boolean;
-  timeoutController: TimeoutController;
+  timeout: Timeout;
   operationName: string;
   waitingLogged: boolean;
   previousServer?: ServerDescription;
@@ -178,6 +178,8 @@ export interface SelectServerOptions {
   session?: ClientSession;
   operationName: string;
   previousServer?: ServerDescription;
+  /** @internal*/
+  timeout?: Timeout;
 }
 
 /** @public */
@@ -215,6 +217,9 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
 
   client!: MongoClient;
 
+  /** @internal */
+  private connectionLock?: Promise<Topology>;
+
   /** @event */
   static readonly SERVER_OPENING = SERVER_OPENING;
   /** @event */
@@ -238,11 +243,6 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
   /** @event */
   static readonly TIMEOUT = TIMEOUT;
 
-  selectServerAsync: (
-    selector: string | ReadPreference | ServerSelector,
-    options: SelectServerOptions
-  ) => Promise<Server>;
-
   /**
    * @param seedlist - a list of HostAddress instances to connect to
    */
@@ -254,14 +254,6 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
     super();
 
     this.client = client;
-    this.selectServerAsync = promisify(
-      (
-        selector: string | ReadPreference | ServerSelector,
-        options: SelectServerOptions,
-        callback: (e: Error, r: Server) => void
-      ) => this.selectServer(selector, options, callback as any)
-    );
-
     // Options should only be undefined in tests, MongoClient will always have defined options
     options = options ?? {
       hosts: [HostAddress.fromString('localhost:27017')],
@@ -351,6 +343,7 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
 
       this.on(Topology.TOPOLOGY_DESCRIPTION_CHANGED, this.s.detectShardedTopology);
     }
+    this.connectionLock = undefined;
   }
 
   private detectShardedTopology(event: TopologyDescriptionChangedEvent) {
@@ -411,17 +404,22 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
   }
 
   /** Initiate server connect */
-  connect(callback: Callback): void;
-  connect(options: ConnectOptions, callback: Callback): void;
-  connect(options?: ConnectOptions | Callback, callback?: Callback): void {
-    if (typeof options === 'function') (callback = options), (options = {});
+  async connect(options?: ConnectOptions): Promise<Topology> {
+    this.connectionLock ??= this._connect(options);
+    try {
+      await this.connectionLock;
+      return this;
+    } finally {
+      this.connectionLock = undefined;
+    }
+
+    return this;
+  }
+
+  private async _connect(options?: ConnectOptions): Promise<Topology> {
     options = options ?? {};
     if (this.s.state === STATE_CONNECTED) {
-      if (typeof callback === 'function') {
-        callback();
-      }
-
-      return;
+      return this;
     }
 
     stateTransition(this, STATE_CONNECTING);
@@ -459,40 +457,33 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
       }
     }
 
-    const exitWithError = (error: Error) =>
-      callback ? callback(error) : this.emit(Topology.ERROR, error);
-
     const readPreference = options.readPreference ?? ReadPreference.primary;
     const selectServerOptions = { operationName: 'ping', ...options };
-    this.selectServer(
-      readPreferenceServerSelector(readPreference),
-      selectServerOptions,
-      (err, server) => {
-        if (err) {
-          this.close();
-          return exitWithError(err);
-        }
-
-        const skipPingOnConnect = this.s.options[Symbol.for('@@mdb.skipPingOnConnect')] === true;
-        if (!skipPingOnConnect && server && this.s.credentials) {
-          server.command(ns('admin.$cmd'), { ping: 1 }, {}).then(() => {
-            stateTransition(this, STATE_CONNECTED);
-            this.emit(Topology.OPEN, this);
-            this.emit(Topology.CONNECT, this);
-
-            callback?.(undefined, this);
-          }, exitWithError);
-
-          return;
-        }
+    try {
+      const server = await this.selectServer(
+        readPreferenceServerSelector(readPreference),
+        selectServerOptions
+      );
 
+      const skipPingOnConnect = this.s.options[Symbol.for('@@mdb.skipPingOnConnect')] === true;
+      if (!skipPingOnConnect && server && this.s.credentials) {
+        await server.command(ns('admin.$cmd'), { ping: 1 }, {});
         stateTransition(this, STATE_CONNECTED);
         this.emit(Topology.OPEN, this);
         this.emit(Topology.CONNECT, this);
 
-        callback?.(undefined, this);
+        return this;
       }
-    );
+
+      stateTransition(this, STATE_CONNECTED);
+      this.emit(Topology.OPEN, this);
+      this.emit(Topology.CONNECT, this);
+
+      return this;
+    } catch (error) {
+      this.close();
+      throw error;
+    }
   }
 
   /** Close this topology */
@@ -533,11 +524,10 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
    * @param callback - The callback used to indicate success or failure
    * @returns An instance of a `Server` meeting the criteria of the predicate provided
    */
-  selectServer(
+  async selectServer(
     selector: string | ReadPreference | ServerSelector,
-    options: SelectServerOptions,
-    callback: Callback<Server>
-  ): void {
+    options: SelectServerOptions
+  ): Promise<Server> {
     let serverSelector;
     if (typeof selector !== 'function') {
       if (typeof selector === 'string') {
@@ -588,53 +578,62 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
           )
         );
       }
-      callback(undefined, transaction.server);
-      return;
+      return transaction.server;
     }
 
+    const { promise: serverPromise, resolve, reject } = promiseWithResolvers<Server>();
+    const timeout = Timeout.expires(options.serverSelectionTimeoutMS ?? 0);
     const waitQueueMember: ServerSelectionRequest = {
       serverSelector,
       topologyDescription: this.description,
       mongoLogger: this.client.mongoLogger,
       transaction,
-      callback,
-      timeoutController: new TimeoutController(options.serverSelectionTimeoutMS),
+      resolve,
+      reject,
+      timeout,
       startTime: now(),
       operationName: options.operationName,
       waitingLogged: false,
       previousServer: options.previousServer
     };
 
-    waitQueueMember.timeoutController.signal.addEventListener('abort', () => {
-      waitQueueMember[kCancelled] = true;
-      waitQueueMember.timeoutController.clear();
-      const timeoutError = new MongoServerSelectionError(
-        `Server selection timed out after ${options.serverSelectionTimeoutMS} ms`,
-        this.description
-      );
-      if (
-        this.client.mongoLogger?.willLog(
-          MongoLoggableComponent.SERVER_SELECTION,
-          SeverityLevel.DEBUG
-        )
-      ) {
-        this.client.mongoLogger?.debug(
-          MongoLoggableComponent.SERVER_SELECTION,
-          new ServerSelectionFailedEvent(
-            selector,
-            this.description,
-            timeoutError,
-            options.operationName
-          )
-        );
-      }
-      waitQueueMember.callback(timeoutError);
-    });
-
     this[kWaitQueue].push(waitQueueMember);
     processWaitQueue(this);
-  }
 
+    try {
+      return await Promise.race([serverPromise, waitQueueMember.timeout]);
+    } catch (error) {
+      if (TimeoutError.is(error)) {
+        // Timeout
+        waitQueueMember[kCancelled] = true;
+        timeout.clear();
+        const timeoutError = new MongoServerSelectionError(
+          `Server selection timed out after ${options.serverSelectionTimeoutMS} ms`,
+          this.description
+        );
+        if (
+          this.client.mongoLogger?.willLog(
+            MongoLoggableComponent.SERVER_SELECTION,
+            SeverityLevel.DEBUG
+          )
+        ) {
+          this.client.mongoLogger?.debug(
+            MongoLoggableComponent.SERVER_SELECTION,
+            new ServerSelectionFailedEvent(
+              selector,
+              this.description,
+              timeoutError,
+              options.operationName
+            )
+          );
+        }
+
+        throw timeoutError;
+      }
+      // Other server selection error
+      throw error;
+    }
+  }
   /**
    * Update the internal TopologyDescription with a ServerDescription
    *
@@ -883,35 +882,33 @@ function updateServers(topology: Topology, incomingServerDescription?: ServerDes
   }
 }
 
-function drainWaitQueue(queue: List<ServerSelectionRequest>, err?: MongoDriverError) {
+function drainWaitQueue(queue: List<ServerSelectionRequest>, drainError: MongoDriverError) {
   while (queue.length) {
     const waitQueueMember = queue.shift();
     if (!waitQueueMember) {
       continue;
     }
 
-    waitQueueMember.timeoutController.clear();
+    waitQueueMember.timeout.clear();
 
     if (!waitQueueMember[kCancelled]) {
-      if (err) {
-        if (
-          waitQueueMember.mongoLogger?.willLog(
-            MongoLoggableComponent.SERVER_SELECTION,
-            SeverityLevel.DEBUG
+      if (
+        waitQueueMember.mongoLogger?.willLog(
+          MongoLoggableComponent.SERVER_SELECTION,
+          SeverityLevel.DEBUG
+        )
+      ) {
+        waitQueueMember.mongoLogger?.debug(
+          MongoLoggableComponent.SERVER_SELECTION,
+          new ServerSelectionFailedEvent(
+            waitQueueMember.serverSelector,
+            waitQueueMember.topologyDescription,
+            drainError,
+            waitQueueMember.operationName
           )
-        ) {
-          waitQueueMember.mongoLogger?.debug(
-            MongoLoggableComponent.SERVER_SELECTION,
-            new ServerSelectionFailedEvent(
-              waitQueueMember.serverSelector,
-              waitQueueMember.topologyDescription,
-              err,
-              waitQueueMember.operationName
-            )
-          );
-        }
+        );
       }
-      waitQueueMember.callback(err);
+      waitQueueMember.reject(drainError);
     }
   }
 }
@@ -946,8 +943,8 @@ function processWaitQueue(topology: Topology) {
             previousServer ? [previousServer] : []
           )
         : serverDescriptions;
-    } catch (e) {
-      waitQueueMember.timeoutController.clear();
+    } catch (selectorError) {
+      waitQueueMember.timeout.clear();
       if (
         topology.client.mongoLogger?.willLog(
           MongoLoggableComponent.SERVER_SELECTION,
@@ -959,12 +956,12 @@ function processWaitQueue(topology: Topology) {
           new ServerSelectionFailedEvent(
             waitQueueMember.serverSelector,
             topology.description,
-            e,
+            selectorError,
             waitQueueMember.operationName
           )
         );
       }
-      waitQueueMember.callback(e);
+      waitQueueMember.reject(selectorError);
       continue;
     }
 
@@ -1007,7 +1004,7 @@ function processWaitQueue(topology: Topology) {
     }
 
     if (!selectedServer) {
-      const error = new MongoServerSelectionError(
+      const serverSelectionError = new MongoServerSelectionError(
         'server selection returned a server description but the server was not found in the topology',
         topology.description
       );
@@ -1022,12 +1019,12 @@ function processWaitQueue(topology: Topology) {
           new ServerSelectionFailedEvent(
             waitQueueMember.serverSelector,
             topology.description,
-            error,
+            serverSelectionError,
             waitQueueMember.operationName
           )
         );
       }
-      waitQueueMember.callback(error);
+      waitQueueMember.reject(serverSelectionError);
       return;
     }
     const transaction = waitQueueMember.transaction;
@@ -1035,7 +1032,7 @@ function processWaitQueue(topology: Topology) {
       transaction.pinServer(selectedServer);
     }
 
-    waitQueueMember.timeoutController.clear();
+    waitQueueMember.timeout.clear();
 
     if (
       topology.client.mongoLogger?.willLog(
@@ -1053,7 +1050,7 @@ function processWaitQueue(topology: Topology) {
         )
       );
     }
-    waitQueueMember.callback(undefined, selectedServer);
+    waitQueueMember.resolve(selectedServer);
   }
 
   if (topology[kWaitQueue].length > 0) {

package/src/sdam/topology_description.ts

@@ -1,6 +1,6 @@
-import type { ObjectId } from '../bson';
+import { EJSON, type ObjectId } from '../bson';
 import * as WIRE_CONSTANTS from '../cmap/wire_protocol/constants';
-import { MongoRuntimeError, type MongoServerError } from '../error';
+import { type MongoError, MongoRuntimeError } from '../error';
 import { compareObjectId, shuffle } from '../utils';
 import { ServerType, TopologyType } from './common';
 import { ServerDescription } from './server_description';
@@ -307,13 +307,13 @@ export class TopologyDescription {
     );
   }
 
-  get error(): MongoServerError | null {
+  get error(): MongoError | null {
     const descriptionsWithError = Array.from(this.servers.values()).filter(
       (sd: ServerDescription) => sd.error
     );
 
     if (descriptionsWithError.length > 0) {
-      return descriptionsWithError[0].error as MongoServerError;
+      return descriptionsWithError[0].error;
     }
 
     return null;
@@ -342,6 +342,16 @@ export class TopologyDescription {
   hasServer(address: string): boolean {
     return this.servers.has(address);
   }
+
+  /**
+   * Returns a JSON-serializable representation of the TopologyDescription.  This is primarily
+   * intended for use with JSON.stringify().
+   *
+   * This method will not throw.
+   */
+  toJSON() {
+    return EJSON.serialize(this);
+  }
 }
 
 function topologyTypeForServerType(serverType: ServerType): TopologyType {