mongodb 4.7.0 → 4.9.0

package/src/sdam/topology.ts

@@ -1,5 +1,6 @@
 import Denque = require('denque');
-import { setTimeout } from 'timers';
+import { clearTimeout, setTimeout } from 'timers';
+import { promisify } from 'util';
 
 import type { BSONSerializeOptions, Document } from '../bson';
 import { deserialize, serialize } from '../bson';
@@ -29,20 +30,14 @@ import {
   MongoServerSelectionError,
   MongoTopologyClosedError
 } from '../error';
-import type { MongoClient, MongoOptions, ServerApi } from '../mongo_client';
+import type { MongoClient, ServerApi } from '../mongo_client';
 import { TypedEventEmitter } from '../mongo_types';
 import { ReadPreference, ReadPreferenceLike } from '../read_preference';
-import {
-  ClientSession,
-  ClientSessionOptions,
-  ServerSessionId,
-  ServerSessionPool
-} from '../sessions';
+import type { ClientSession } from '../sessions';
 import type { Transaction } from '../transactions';
 import {
   Callback,
   ClientMetadata,
-  eachAsync,
   emitWarning,
   EventEmitterWithState,
   HostAddress,
@@ -120,10 +115,6 @@ export interface TopologyPrivate {
   minHeartbeatFrequencyMS: number;
   /** A map of server instances to normalized addresses */
   servers: Map<string, Server>;
-  /** Server Session Pool */
-  sessionPool: ServerSessionPool;
-  /** Active client sessions */
-  sessions: Set<ClientSession>;
   credentials?: MongoCredentials;
   clusterTime?: ClusterTime;
   /** timers created for the initial connect to a server */
@@ -316,10 +307,6 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
       minHeartbeatFrequencyMS: options.minHeartbeatFrequencyMS,
       // a map of server instances to normalized addresses
       servers: new Map(),
-      // Server Session Pool
-      sessionPool: new ServerSessionPool(this),
-      // Active client sessions
-      sessions: new Set(),
       credentials: options?.credentials,
       clusterTime: undefined,
 
@@ -443,13 +430,13 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
       }
     }
 
+    const exitWithError = (error: Error) =>
+      callback ? callback(error) : this.emit(Topology.ERROR, error);
+
     const readPreference = options.readPreference ?? ReadPreference.primary;
     this.selectServer(readPreferenceServerSelector(readPreference), options, (err, server) => {
       if (err) {
-        this.close();
-
-        typeof callback === 'function' ? callback(err) : this.emit(Topology.ERROR, err);
-        return;
+        return this.close({ force: false }, () => exitWithError(err));
       }
 
       // TODO: NODE-2471
@@ -457,15 +444,14 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
       if (!skipPingOnConnect && server && this.s.credentials) {
         server.command(ns('admin.$cmd'), { ping: 1 }, {}, err => {
           if (err) {
-            typeof callback === 'function' ? callback(err) : this.emit(Topology.ERROR, err);
-            return;
+            return exitWithError(err);
           }
 
           stateTransition(this, STATE_CONNECTED);
           this.emit(Topology.OPEN, this);
           this.emit(Topology.CONNECT, this);
 
-          if (typeof callback === 'function') callback(undefined, this);
+          callback?.(undefined, this);
         });
 
         return;
@@ -475,7 +461,7 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
       this.emit(Topology.OPEN, this);
       this.emit(Topology.CONNECT, this);
 
-      if (typeof callback === 'function') callback(undefined, this);
+      callback?.(undefined, this);
     });
   }
 
@@ -489,52 +475,38 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
     if (typeof options === 'boolean') {
       options = { force: options };
     }
-
     options = options ?? {};
-    if (this.s.state === STATE_CLOSED || this.s.state === STATE_CLOSING) {
-      if (typeof callback === 'function') {
-        callback();
-      }
 
-      return;
+    if (this.s.state === STATE_CLOSED || this.s.state === STATE_CLOSING) {
+      return callback?.();
     }
 
-    stateTransition(this, STATE_CLOSING);
+    const destroyedServers = Array.from(this.s.servers.values(), server => {
+      return promisify(destroyServer)(server, this, options);
+    });
 
-    drainWaitQueue(this[kWaitQueue], new MongoTopologyClosedError());
-    drainTimerQueue(this.s.connectionTimers);
+    Promise.all(destroyedServers)
+      .then(() => {
+        this.s.servers.clear();
 
-    if (this.s.srvPoller) {
-      this.s.srvPoller.stop();
-      this.s.srvPoller.removeListener(SrvPoller.SRV_RECORD_DISCOVERY, this.s.detectSrvRecords);
-    }
+        stateTransition(this, STATE_CLOSING);
 
-    this.removeListener(Topology.TOPOLOGY_DESCRIPTION_CHANGED, this.s.detectShardedTopology);
-
-    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);
-              }
-            }
-          );
-        });
-      }
-    );
+        drainWaitQueue(this[kWaitQueue], new MongoTopologyClosedError());
+        drainTimerQueue(this.s.connectionTimers);
+
+        if (this.s.srvPoller) {
+          this.s.srvPoller.stop();
+          this.s.srvPoller.removeListener(SrvPoller.SRV_RECORD_DISCOVERY, this.s.detectSrvRecords);
+        }
+
+        this.removeListener(Topology.TOPOLOGY_DESCRIPTION_CHANGED, this.s.detectShardedTopology);
+
+        stateTransition(this, STATE_CLOSED);
+
+        // emit an event for close
+        this.emit(Topology.TOPOLOGY_CLOSED, new TopologyClosedEvent(this.s.id));
+      })
+      .finally(() => callback?.());
   }
 
   /**
@@ -628,44 +600,6 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
     return this.loadBalanced || this.description.logicalSessionTimeoutMinutes != null;
   }
 
-  /** Start a logical session */
-  startSession(options: ClientSessionOptions, clientOptions?: MongoOptions): ClientSession {
-    const session = new ClientSession(this.client, this.s.sessionPool, options, clientOptions);
-    session.once('ended', () => {
-      this.s.sessions.delete(session);
-    });
-
-    this.s.sessions.add(session);
-    return session;
-  }
-
-  /** Send endSessions command(s) with the given session ids */
-  endSessions(sessions: ServerSessionId[], callback?: Callback<Document>): void {
-    if (!Array.isArray(sessions)) {
-      sessions = [sessions];
-    }
-
-    this.selectServer(
-      readPreferenceServerSelector(ReadPreference.primaryPreferred),
-      {},
-      (err, server) => {
-        if (err || !server) {
-          if (typeof callback === 'function') callback(err);
-          return;
-        }
-
-        server.command(
-          ns('admin.$cmd'),
-          { endSessions: sessions },
-          { noResponse: true },
-          (err, result) => {
-            if (typeof callback === 'function') callback(err, result);
-          }
-        );
-      }
-    );
-  }
-
   /**
    * Update the internal TopologyDescription with a ServerDescription
    *
@@ -790,7 +724,7 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
     return this.description.commonWireVersion;
   }
 
-  get logicalSessionTimeoutMinutes(): number | undefined {
+  get logicalSessionTimeoutMinutes(): number | null {
     return this.description.logicalSessionTimeoutMinutes;
   }
 

package/src/sdam/topology_description.ts

@@ -1,7 +1,7 @@
-import type { Document, ObjectId } from '../bson';
+import type { ObjectId } from '../bson';
 import * as WIRE_CONSTANTS from '../cmap/wire_protocol/constants';
-import { MongoError, MongoRuntimeError } from '../error';
-import { shuffle } from '../utils';
+import { MongoRuntimeError, MongoServerError } from '../error';
+import { compareObjectId, shuffle } from '../utils';
 import { ServerType, TopologyType } from './common';
 import { ServerDescription } from './server_description';
 import type { SrvPollingEvent } from './srv_polling';
@@ -32,29 +32,29 @@ export interface TopologyDescriptionOptions {
  */
 export class TopologyDescription {
   type: TopologyType;
-  setName?: string;
-  maxSetVersion?: number;
-  maxElectionId?: ObjectId;
+  setName: string | null;
+  maxSetVersion: number | null;
+  maxElectionId: ObjectId | null;
   servers: Map<string, ServerDescription>;
   stale: boolean;
   compatible: boolean;
   compatibilityError?: string;
-  logicalSessionTimeoutMinutes?: number;
+  logicalSessionTimeoutMinutes: number | null;
   heartbeatFrequencyMS: number;
   localThresholdMS: number;
-  commonWireVersion?: number;
+  commonWireVersion: number;
 
   /**
    * Create a TopologyDescription
    */
   constructor(
     topologyType: TopologyType,
-    serverDescriptions?: Map<string, ServerDescription>,
-    setName?: string,
-    maxSetVersion?: number,
-    maxElectionId?: ObjectId,
-    commonWireVersion?: number,
-    options?: TopologyDescriptionOptions
+    serverDescriptions: Map<string, ServerDescription> | null = null,
+    setName: string | null = null,
+    maxSetVersion: number | null = null,
+    maxElectionId: ObjectId | null = null,
+    commonWireVersion: number | null = null,
+    options: TopologyDescriptionOptions | null = null
   ) {
     options = options ?? {};
 
@@ -64,22 +64,10 @@ export class TopologyDescription {
     this.compatible = true;
     this.heartbeatFrequencyMS = options.heartbeatFrequencyMS ?? 0;
     this.localThresholdMS = options.localThresholdMS ?? 15;
-
-    if (setName) {
-      this.setName = setName;
-    }
-
-    if (maxSetVersion) {
-      this.maxSetVersion = maxSetVersion;
-    }
-
-    if (maxElectionId) {
-      this.maxElectionId = maxElectionId;
-    }
-
-    if (commonWireVersion) {
-      this.commonWireVersion = commonWireVersion;
-    }
+    this.setName = setName ?? null;
+    this.maxElectionId = maxElectionId ?? null;
+    this.maxSetVersion = maxSetVersion ?? null;
+    this.commonWireVersion = commonWireVersion ?? 0;
 
     // determine server compatibility
     for (const serverDescription of this.servers.values()) {
@@ -108,12 +96,12 @@ export class TopologyDescription {
     // value among ServerDescriptions of all data-bearing server types. If any have a null
     // logicalSessionTimeoutMinutes, then TopologyDescription.logicalSessionTimeoutMinutes MUST be
     // set to null.
-    this.logicalSessionTimeoutMinutes = undefined;
+    this.logicalSessionTimeoutMinutes = null;
     for (const [, server] of this.servers) {
       if (server.isReadable) {
         if (server.logicalSessionTimeoutMinutes == null) {
           // If any of the servers have a null logicalSessionsTimeout, then the whole topology does
-          this.logicalSessionTimeoutMinutes = undefined;
+          this.logicalSessionTimeoutMinutes = null;
           break;
         }
 
@@ -200,11 +188,6 @@ export class TopologyDescription {
     // potentially mutated values
     let { type: topologyType, setName, maxSetVersion, maxElectionId, commonWireVersion } = this;
 
-    if (serverDescription.setName && setName && serverDescription.setName !== setName) {
-      // TODO(NODE-4159): servers with an incorrect setName should be removed not marked Unknown
-      serverDescription = new ServerDescription(address, undefined);
-    }
-
     const serverType = serverDescription.type;
     const serverDescriptions = new Map(this.servers);
 
@@ -217,6 +200,19 @@ export class TopologyDescription {
       }
     }
 
+    if (
+      typeof serverDescription.setName === 'string' &&
+      typeof setName === 'string' &&
+      serverDescription.setName !== setName
+    ) {
+      if (topologyType === TopologyType.Single) {
+        // "Single" Topology with setName mismatch is direct connection usage, mark unknown do not remove
+        serverDescription = new ServerDescription(address);
+      } else {
+        serverDescriptions.delete(address);
+      }
+    }
+
     // update the actual server description
     serverDescriptions.set(address, serverDescription);
 
@@ -311,7 +307,7 @@ export class TopologyDescription {
     );
   }
 
-  get error(): MongoError | undefined {
+  get error(): MongoServerError | null {
     const descriptionsWithError = Array.from(this.servers.values()).filter(
       (sd: ServerDescription) => sd.error
     );
@@ -319,7 +315,8 @@ export class TopologyDescription {
     if (descriptionsWithError.length > 0) {
       return descriptionsWithError[0].error;
     }
-    return;
+
+    return null;
   }
 
   /**
@@ -363,34 +360,13 @@ function topologyTypeForServerType(serverType: ServerType): TopologyType {
   }
 }
 
-// TODO: improve these docs when ObjectId is properly typed
-function compareObjectId(oid1: Document, oid2: Document): number {
-  if (oid1 == null) {
-    return -1;
-  }
-
-  if (oid2 == null) {
-    return 1;
-  }
-
-  if (oid1.id instanceof Buffer && oid2.id instanceof Buffer) {
-    const oid1Buffer = oid1.id;
-    const oid2Buffer = oid2.id;
-    return oid1Buffer.compare(oid2Buffer);
-  }
-
-  const oid1String = oid1.toString();
-  const oid2String = oid2.toString();
-  return oid1String.localeCompare(oid2String);
-}
-
 function updateRsFromPrimary(
   serverDescriptions: Map<string, ServerDescription>,
   serverDescription: ServerDescription,
-  setName?: string,
-  maxSetVersion?: number,
-  maxElectionId?: ObjectId
-): [TopologyType, string?, number?, ObjectId?] {
+  setName: string | null = null,
+  maxSetVersion: number | null = null,
+  maxElectionId: ObjectId | null = null
+): [TopologyType, string | null, number | null, ObjectId | null] {
   setName = setName || serverDescription.setName;
   if (setName !== serverDescription.setName) {
     serverDescriptions.delete(serverDescription.address);
@@ -457,7 +433,7 @@ function updateRsFromPrimary(
 function updateRsWithPrimaryFromMember(
   serverDescriptions: Map<string, ServerDescription>,
   serverDescription: ServerDescription,
-  setName?: string
+  setName: string | null = null
 ): TopologyType {
   if (setName == null) {
     // TODO(NODE-3483): should be an appropriate runtime error
@@ -477,10 +453,10 @@ function updateRsWithPrimaryFromMember(
 function updateRsNoPrimaryFromMember(
   serverDescriptions: Map<string, ServerDescription>,
   serverDescription: ServerDescription,
-  setName?: string
-): [TopologyType, string?] {
+  setName: string | null = null
+): [TopologyType, string | null] {
   const topologyType = TopologyType.ReplicaSetNoPrimary;
-  setName = setName || serverDescription.setName;
+  setName = setName ?? serverDescription.setName;
   if (setName !== serverDescription.setName) {
     serverDescriptions.delete(serverDescription.address);
     return [topologyType, setName];

package/src/sessions.ts

@@ -27,7 +27,6 @@ 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 {
   calculateDurationInMs,
@@ -269,9 +268,10 @@ export class ClientSession extends TypedEventEmitter<ClientSessionEvents> {
         if (serverSession != null) {
           // release the server session back to the pool
           this.sessionPool.release(serverSession);
-          // Make sure a new serverSession never makes it on to the ClientSession
+          // Make sure a new serverSession never makes it onto this ClientSession
           Object.defineProperty(this, kServerSession, {
-            value: ServerSession.clone(serverSession)
+            value: ServerSession.clone(serverSession),
+            writable: false
           });
         }
 
@@ -383,7 +383,7 @@ export class ClientSession extends TypedEventEmitter<ClientSessionEvents> {
    */
   startTransaction(options?: TransactionOptions): void {
     if (this[kSnapshotEnabled]) {
-      throw new MongoCompatibilityError('Transactions are not allowed with snapshot sessions');
+      throw new MongoCompatibilityError('Transactions are not supported in snapshot sessions');
     }
 
     if (this.inTransaction()) {
@@ -616,7 +616,7 @@ function attemptTransaction<TSchema>(
   }
 
   if (!isPromiseLike(promise)) {
-    session.abortTransaction();
+    session.abortTransaction().catch(() => null);
     throw new MongoInvalidArgumentError(
       'Function provided to `withTransaction` must return a Promise'
     );
@@ -878,39 +878,18 @@ export class ServerSession {
  * @internal
  */
 export class ServerSessionPool {
-  topology: Topology;
+  client: MongoClient;
   sessions: ServerSession[];
 
-  constructor(topology: Topology) {
-    if (topology == null) {
-      throw new MongoRuntimeError('ServerSessionPool requires a topology');
+  constructor(client: MongoClient) {
+    if (client == null) {
+      throw new MongoRuntimeError('ServerSessionPool requires a MongoClient');
     }
 
-    this.topology = topology;
+    this.client = client;
     this.sessions = [];
   }
 
-  /** Ends all sessions in the session pool */
-  endAllPooledSessions(callback?: Callback<void>): void {
-    if (this.sessions.length) {
-      this.topology.endSessions(
-        this.sessions.map((session: ServerSession) => session.id),
-        () => {
-          this.sessions = [];
-          if (typeof callback === 'function') {
-            callback();
-          }
-        }
-      );
-
-      return;
-    }
-
-    if (typeof callback === 'function') {
-      callback();
-    }
-  }
-
   /**
    * Acquire a Server Session from the pool.
    * Iterates through each session in the pool, removing any stale sessions
@@ -918,16 +897,29 @@ export class ServerSessionPool {
    * pool and returned. If no non-stale session is found, a new ServerSession is created.
    */
   acquire(): ServerSession {
-    const sessionTimeoutMinutes = this.topology.logicalSessionTimeoutMinutes || 10;
+    const sessionTimeoutMinutes = this.client.topology?.logicalSessionTimeoutMinutes ?? 10;
 
-    while (this.sessions.length) {
-      const session = this.sessions.shift();
-      if (session && (this.topology.loadBalanced || !session.hasTimedOut(sessionTimeoutMinutes))) {
-        return session;
+    let session: ServerSession | null = null;
+
+    // Try to obtain from session pool
+    while (this.sessions.length > 0) {
+      const potentialSession = this.sessions.shift();
+      if (
+        potentialSession != null &&
+        (!!this.client.topology?.loadBalanced ||
+          !potentialSession.hasTimedOut(sessionTimeoutMinutes))
+      ) {
+        session = potentialSession;
+        break;
       }
     }
 
-    return new ServerSession();
+    // If nothing valid came from the pool make a new one
+    if (session == null) {
+      session = new ServerSession();
+    }
+
+    return session;
   }
 
   /**
@@ -938,9 +930,9 @@ export class ServerSessionPool {
    * @param session - The session to release to the pool
    */
   release(session: ServerSession): void {
-    const sessionTimeoutMinutes = this.topology.logicalSessionTimeoutMinutes;
+    const sessionTimeoutMinutes = this.client.topology?.logicalSessionTimeoutMinutes ?? 10;
 
-    if (this.topology.loadBalanced && !sessionTimeoutMinutes) {
+    if (this.client.topology?.loadBalanced && !sessionTimeoutMinutes) {
       this.sessions.unshift(session);
     }
 
@@ -1010,6 +1002,7 @@ export function applySession(
   if (isRetryableWrite || inTxnOrTxnCommand) {
     serverSession.txnNumber += session[kTxnNumberIncrement];
     session[kTxnNumberIncrement] = 0;
+    // TODO(NODE-2674): Preserve int64 sent from MongoDB
     command.txnNumber = Long.fromNumber(serverSession.txnNumber);
   }