mongodb 4.3.1 → 4.5.0

package/src/sdam/topology.ts

@@ -50,7 +50,6 @@ import {
 } from '../utils';
 import {
   _advanceClusterTime,
-  clearAndRemoveTimerFrom,
   ClusterTime,
   drainTimerQueue,
   ServerType,
@@ -435,7 +434,12 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
 
     // connect all known servers, then attempt server selection to connect
     const serverDescriptions = Array.from(this.s.description.servers.values());
-    connectServers(this, serverDescriptions);
+    this.s.servers = new Map(
+      serverDescriptions.map(serverDescription => [
+        serverDescription.address,
+        createAndConnectServer(this, serverDescription)
+      ])
+    );
 
     // In load balancer mode we need to fake a server description getting
     // emitted from the monitor, since the monitor doesn't exist.
@@ -459,7 +463,7 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
 
       // TODO: NODE-2471
       if (server && this.s.credentials) {
-        server.command(ns('admin.$cmd'), { ping: 1 }, err => {
+        server.command(ns('admin.$cmd'), { ping: 1 }, {}, err => {
           if (err) {
             typeof callback === 'function' ? callback(err) : this.emit(Topology.ERROR, err);
             return;
@@ -549,27 +553,11 @@ 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(options: SelectServerOptions, callback: Callback<Server>): void;
-  selectServer(
-    selector: string | ReadPreference | ServerSelector,
-    callback: Callback<Server>
-  ): void;
   selectServer(
     selector: string | ReadPreference | ServerSelector,
     options: SelectServerOptions,
     callback: Callback<Server>
-  ): void;
-  selectServer(
-    selector: string | ReadPreference | ServerSelector | SelectServerOptions,
-    _options?: SelectServerOptions | Callback<Server>,
-    _callback?: Callback<Server>
   ): void {
-    let options = _options as SelectServerOptions;
-    const callback = (_callback ?? _options) as Callback<Server>;
-    if (typeof options === 'function') {
-      options = {};
-    }
-
     let serverSelector;
     if (typeof selector !== 'function') {
       if (typeof selector === 'string') {
@@ -667,6 +655,7 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
 
     this.selectServer(
       readPreferenceServerSelector(ReadPreference.primaryPreferred),
+      {},
       (err, server) => {
         if (err || !server) {
           if (typeof callback === 'function') callback(err);
@@ -875,13 +864,8 @@ function randomSelection(array: ServerDescription[]): ServerDescription {
  *
  * @param topology - The topology that this server belongs to
  * @param serverDescription - The description for the server to initialize and connect to
- * @param connectDelay - Time to wait before attempting initial connection
  */
-function createAndConnectServer(
-  topology: Topology,
-  serverDescription: ServerDescription,
-  connectDelay?: number
-) {
+function createAndConnectServer(topology: Topology, serverDescription: ServerDescription) {
   topology.emit(
     Topology.SERVER_OPENING,
     new ServerOpeningEvent(topology.s.id, serverDescription.address)
@@ -894,38 +878,10 @@ function createAndConnectServer(
 
   server.on(Server.DESCRIPTION_RECEIVED, description => topology.serverUpdateHandler(description));
 
-  if (connectDelay) {
-    const connectTimer = setTimeout(() => {
-      clearAndRemoveTimerFrom(connectTimer, topology.s.connectionTimers);
-      server.connect();
-    }, connectDelay);
-
-    topology.s.connectionTimers.add(connectTimer);
-    return server;
-  }
-
   server.connect();
   return server;
 }
 
-/**
- * Create `Server` instances for all initially known servers, connect them, and assign
- * them to the passed in `Topology`.
- *
- * @param topology - The topology responsible for the servers
- * @param serverDescriptions - A list of server descriptions to connect
- */
-function connectServers(topology: Topology, serverDescriptions: ServerDescription[]) {
-  topology.s.servers = serverDescriptions.reduce(
-    (servers: Map<string, Server>, serverDescription: ServerDescription) => {
-      const server = createAndConnectServer(topology, serverDescription);
-      servers.set(serverDescription.address, server);
-      return servers;
-    },
-    new Map<string, Server>()
-  );
-}
-
 /**
  * @param topology - Topology to update.
  * @param incomingServerDescription - New server description.

package/src/sdam/topology_description.ts

@@ -58,9 +58,6 @@ export class TopologyDescription {
   ) {
     options = options ?? {};
 
-    // TODO: consider assigning all these values to a temporary value `s` which
-    //       we use `Object.freeze` on, ensuring the internal state of this type
-    //       is immutable.
     this.type = topologyType ?? TopologyType.Unknown;
     this.servers = serverDescriptions ?? new Map();
     this.stale = false;
@@ -321,6 +318,7 @@ export class TopologyDescription {
     if (descriptionsWithError.length > 0) {
       return descriptionsWithError[0].error;
     }
+    return;
   }
 
   /**

package/src/sessions.ts

@@ -6,16 +6,14 @@ import { PINNED, UNPINNED } from './constants';
 import type { AbstractCursor } from './cursor/abstract_cursor';
 import {
   AnyError,
-  isRetryableEndTransactionError,
-  isRetryableError,
   MongoAPIError,
   MongoCompatibilityError,
   MONGODB_ERROR_CODES,
   MongoDriverError,
   MongoError,
+  MongoErrorLabel,
   MongoExpiredSessionError,
   MongoInvalidArgumentError,
-  MongoNetworkError,
   MongoRuntimeError,
   MongoServerError,
   MongoTransactionError,
@@ -41,24 +39,9 @@ import {
   now,
   uuidV4
 } from './utils';
-import type { WriteConcern } from './write_concern';
 
 const minWireVersionForShardedTransactions = 8;
 
-function assertAlive(session: ClientSession, callback?: Callback): boolean {
-  if (session.serverSession == null) {
-    const error = new MongoExpiredSessionError();
-    if (typeof callback === 'function') {
-      callback(error);
-      return false;
-    }
-
-    throw error;
-  }
-
-  return true;
-}
-
 /** @public */
 export interface ClientSessionOptions {
   /** Whether causal consistency should be enabled on this session */
@@ -92,6 +75,8 @@ const kSnapshotTime = Symbol('snapshotTime');
 const kSnapshotEnabled = Symbol('snapshotEnabled');
 /** @internal */
 const kPinnedConnection = Symbol('pinnedConnection');
+/** @internal Accumulates total number of increments to add to txnNumber when applying session to command */
+const kTxnNumberIncrement = Symbol('txnNumberIncrement');
 
 /** @public */
 export interface EndSessionOptions {
@@ -126,13 +111,15 @@ export class ClientSession extends TypedEventEmitter<ClientSessionEvents> {
   defaultTransactionOptions: TransactionOptions;
   transaction: Transaction;
   /** @internal */
-  [kServerSession]?: ServerSession;
+  [kServerSession]: ServerSession | null;
   /** @internal */
   [kSnapshotTime]?: Timestamp;
   /** @internal */
   [kSnapshotEnabled] = false;
   /** @internal */
   [kPinnedConnection]?: Connection;
+  /** @internal */
+  [kTxnNumberIncrement]: number;
 
   /**
    * Create a client session.
@@ -175,7 +162,10 @@ export class ClientSession extends TypedEventEmitter<ClientSessionEvents> {
     this.sessionPool = sessionPool;
     this.hasEnded = false;
     this.clientOptions = clientOptions;
-    this[kServerSession] = undefined;
+
+    this.explicit = !!options.explicit;
+    this[kServerSession] = this.explicit ? this.sessionPool.acquire() : null;
+    this[kTxnNumberIncrement] = 0;
 
     this.supports = {
       causalConsistency: options.snapshot !== true && options.causalConsistency !== false
@@ -184,7 +174,6 @@ export class ClientSession extends TypedEventEmitter<ClientSessionEvents> {
     this.clusterTime = options.initialClusterTime;
 
     this.operationTime = undefined;
-    this.explicit = !!options.explicit;
     this.owner = options.owner;
     this.defaultTransactionOptions = Object.assign({}, options.defaultTransactionOptions);
     this.transaction = new Transaction();
@@ -192,16 +181,22 @@ export class ClientSession extends TypedEventEmitter<ClientSessionEvents> {
 
   /** The server id associated with this session */
   get id(): ServerSessionId | undefined {
-    return this.serverSession?.id;
+    return this[kServerSession]?.id;
   }
 
   get serverSession(): ServerSession {
-    if (this[kServerSession] == null) {
-      this[kServerSession] = this.sessionPool.acquire();
+    let serverSession = this[kServerSession];
+    if (serverSession == null) {
+      if (this.explicit) {
+        throw new MongoRuntimeError('Unexpected null serverSession for an explicit session');
+      }
+      if (this.hasEnded) {
+        throw new MongoRuntimeError('Unexpected null serverSession for an ended implicit session');
+      }
+      serverSession = this.sessionPool.acquire();
+      this[kServerSession] = serverSession;
     }
-
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    return this[kServerSession]!;
+    return serverSession;
   }
 
   /** Whether or not this session is configured for snapshot reads */
@@ -270,9 +265,15 @@ export class ClientSession extends TypedEventEmitter<ClientSessionEvents> {
       const completeEndSession = () => {
         maybeClearPinnedConnection(this, finalOptions);
 
-        // release the server session back to the pool
-        this.sessionPool.release(this.serverSession);
-        this[kServerSession] = undefined;
+        const serverSession = this[kServerSession];
+        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
+          Object.defineProperty(this, kServerSession, {
+            value: ServerSession.clone(serverSession)
+          });
+        }
 
         // mark the session as ended, and emit a signal
         this.hasEnded = true;
@@ -282,7 +283,9 @@ export class ClientSession extends TypedEventEmitter<ClientSessionEvents> {
         done();
       };
 
-      if (this.serverSession && this.inTransaction()) {
+      if (this.inTransaction()) {
+        // If we've reached endSession and the transaction is still active
+        // by default we abort it
         this.abortTransaction(err => {
           if (err) return done(err);
           completeEndSession();
@@ -356,12 +359,16 @@ export class ClientSession extends TypedEventEmitter<ClientSessionEvents> {
     return this.id.id.buffer.equals(session.id.id.buffer);
   }
 
-  /** Increment the transaction number on the internal ServerSession */
+  /**
+   * Increment the transaction number on the internal ServerSession
+   *
+   * @privateRemarks
+   * This helper increments a value stored on the client session that will be
+   * added to the serverSession's txnNumber upon applying it to a command.
+   * This is because the serverSession is lazily acquired after a connection is obtained
+   */
   incrementTransactionNumber(): void {
-    if (this.serverSession) {
-      this.serverSession.txnNumber =
-        typeof this.serverSession.txnNumber === 'number' ? this.serverSession.txnNumber + 1 : 0;
-    }
+    this[kTxnNumberIncrement] += 1;
   }
 
   /** @returns whether this session is currently in a transaction or not */
@@ -379,7 +386,6 @@ export class ClientSession extends TypedEventEmitter<ClientSessionEvents> {
       throw new MongoCompatibilityError('Transactions are not allowed with snapshot sessions');
     }
 
-    assertAlive(this);
     if (this.inTransaction()) {
       throw new MongoTransactionError('Transaction already in progress');
     }
@@ -507,7 +513,7 @@ export function maybeClearPinnedConnection(
     session.inTransaction() &&
     error &&
     error instanceof MongoError &&
-    error.hasErrorLabel('TransientTransactionError')
+    error.hasErrorLabel(MongoErrorLabel.TransientTransactionError)
   ) {
     return;
   }
@@ -559,11 +565,11 @@ function attemptTransactionCommit<T>(
       hasNotTimedOut(startTime, MAX_WITH_TRANSACTION_TIMEOUT) &&
       !isMaxTimeMSExpiredError(err)
     ) {
-      if (err.hasErrorLabel('UnknownTransactionCommitResult')) {
+      if (err.hasErrorLabel(MongoErrorLabel.UnknownTransactionCommitResult)) {
         return attemptTransactionCommit(session, startTime, fn, options);
       }
 
-      if (err.hasErrorLabel('TransientTransactionError')) {
+      if (err.hasErrorLabel(MongoErrorLabel.TransientTransactionError)) {
         return attemptTransaction(session, startTime, fn, options);
       }
     }
@@ -617,20 +623,20 @@ function attemptTransaction<TSchema>(
       function maybeRetryOrThrow(err: MongoError): Promise<any> {
         if (
           err instanceof MongoError &&
-          err.hasErrorLabel('TransientTransactionError') &&
+          err.hasErrorLabel(MongoErrorLabel.TransientTransactionError) &&
           hasNotTimedOut(startTime, MAX_WITH_TRANSACTION_TIMEOUT)
         ) {
           return attemptTransaction(session, startTime, fn, options);
         }
 
         if (isMaxTimeMSExpiredError(err)) {
-          err.addErrorLabel('UnknownTransactionCommitResult');
+          err.addErrorLabel(MongoErrorLabel.UnknownTransactionCommitResult);
         }
 
         throw err;
       }
 
-      if (session.transaction.isActive) {
+      if (session.inTransaction()) {
         return session.abortTransaction().then(() => maybeRetryOrThrow(err));
       }
 
@@ -639,12 +645,11 @@ function attemptTransaction<TSchema>(
   );
 }
 
-function endTransaction(session: ClientSession, commandName: string, callback: Callback<Document>) {
-  if (!assertAlive(session, callback)) {
-    // checking result in case callback was called
-    return;
-  }
-
+function endTransaction(
+  session: ClientSession,
+  commandName: 'abortTransaction' | 'commitTransaction',
+  callback: Callback<Document>
+) {
   // handle any initial problematic cases
   const txnState = session.transaction.state;
 
@@ -717,7 +722,7 @@ function endTransaction(session: ClientSession, commandName: string, callback: C
     Object.assign(command, { maxTimeMS: session.transaction.options.maxTimeMS });
   }
 
-  function commandHandler(e?: MongoError, r?: Document) {
+  function commandHandler(error?: Error, result?: Document) {
     if (commandName !== 'commitTransaction') {
       session.transaction.transition(TxnState.TRANSACTION_ABORTED);
       if (session.loadBalanced) {
@@ -729,47 +734,45 @@ function endTransaction(session: ClientSession, commandName: string, callback: C
     }
 
     session.transaction.transition(TxnState.TRANSACTION_COMMITTED);
-    if (e) {
+    if (error instanceof MongoError) {
       if (
-        e instanceof MongoNetworkError ||
-        e instanceof MongoWriteConcernError ||
-        isRetryableError(e) ||
-        isMaxTimeMSExpiredError(e)
+        error.hasErrorLabel(MongoErrorLabel.RetryableWriteError) ||
+        error instanceof MongoWriteConcernError ||
+        isMaxTimeMSExpiredError(error)
       ) {
-        if (isUnknownTransactionCommitResult(e)) {
-          e.addErrorLabel('UnknownTransactionCommitResult');
+        if (isUnknownTransactionCommitResult(error)) {
+          error.addErrorLabel(MongoErrorLabel.UnknownTransactionCommitResult);
 
           // per txns spec, must unpin session in this case
-          session.unpin({ error: e });
+          session.unpin({ error });
         }
-      } else if (e.hasErrorLabel('TransientTransactionError')) {
-        session.unpin({ error: e });
+      } else if (error.hasErrorLabel(MongoErrorLabel.TransientTransactionError)) {
+        session.unpin({ error });
       }
     }
 
-    callback(e, r);
+    callback(error, result);
   }
 
-  // Assumption here that commandName is "commitTransaction" or "abortTransaction"
   if (session.transaction.recoveryToken) {
     command.recoveryToken = session.transaction.recoveryToken;
   }
 
   // send the command
   executeOperation(
-    session.topology,
+    session,
     new RunAdminCommandOperation(undefined, command, {
       session,
       readPreference: ReadPreference.primary,
       bypassPinningCheck: true
     }),
-    (err, reply) => {
+    (error, result) => {
       if (command.abortTransaction) {
         // always unpin on abort regardless of command outcome
         session.unpin();
       }
 
-      if (err && isRetryableEndTransactionError(err as MongoError)) {
+      if (error instanceof MongoError && error.hasErrorLabel(MongoErrorLabel.RetryableWriteError)) {
         // SPEC-1185: apply majority write concern when retrying commitTransaction
         if (command.commitTransaction) {
           // per txns spec, must unpin session in this case
@@ -781,17 +784,17 @@ function endTransaction(session: ClientSession, commandName: string, callback: C
         }
 
         return executeOperation(
-          session.topology,
+          session,
           new RunAdminCommandOperation(undefined, command, {
             session,
             readPreference: ReadPreference.primary,
             bypassPinningCheck: true
           }),
-          (_err, _reply) => commandHandler(_err as MongoError, _reply)
+          commandHandler
         );
       }
 
-      commandHandler(err as MongoError, reply);
+      commandHandler(error, result);
     }
   );
 }
@@ -832,6 +835,30 @@ export class ServerSession {
 
     return idleTimeMinutes > sessionTimeoutMinutes - 1;
   }
+
+  /**
+   * @internal
+   * Cloning meant to keep a readable reference to the server session data
+   * after ClientSession has ended
+   */
+  static clone(serverSession: ServerSession): Readonly<ServerSession> {
+    const arrayBuffer = new ArrayBuffer(16);
+    const idBytes = Buffer.from(arrayBuffer);
+    idBytes.set(serverSession.id.id.buffer);
+
+    const id = new Binary(idBytes, serverSession.id.id.sub_type);
+
+    // Manual prototype construction to avoid modifying the constructor of this class
+    return Object.setPrototypeOf(
+      {
+        id: { id },
+        lastUse: serverSession.lastUse,
+        txnNumber: serverSession.txnNumber,
+        isDirty: serverSession.isDirty
+      },
+      ServerSession.prototype
+    );
+  }
 }
 
 /**
@@ -936,26 +963,27 @@ export class ServerSessionPool {
  * @param session - the session tracking transaction state
  * @param command - the command to decorate
  * @param options - Optional settings passed to calling operation
+ *
+ * @internal
  */
 export function applySession(
   session: ClientSession,
   command: Document,
-  options?: CommandOptions
+  options: CommandOptions
 ): MongoDriverError | undefined {
-  // TODO: merge this with `assertAlive`, did not want to throw a try/catch here
   if (session.hasEnded) {
     return new MongoExpiredSessionError();
   }
 
+  // May acquire serverSession here
   const serverSession = session.serverSession;
   if (serverSession == null) {
     return new MongoRuntimeError('Unable to acquire server session');
   }
 
-  // SPEC-1019: silently ignore explicit session with unacknowledged write for backwards compatibility
-  // FIXME: NODE-2781, this check for write concern shouldn't be happening here, but instead during command construction
-  if (options && options.writeConcern && (options.writeConcern as WriteConcern).w === 0) {
+  if (options.writeConcern?.w === 0) {
     if (session && session.explicit) {
+      // Error if user provided an explicit session to an unacknowledged write (SPEC-1019)
       return new MongoAPIError('Cannot have explicit session with unacknowledged writes');
     }
     return;
@@ -965,15 +993,16 @@ export function applySession(
   serverSession.lastUse = now();
   command.lsid = serverSession.id;
 
-  // first apply non-transaction-specific sessions data
-  const inTransaction = session.inTransaction() || isTransactionCommand(command);
-  const isRetryableWrite = options?.willRetryWrite || false;
+  const inTxnOrTxnCommand = session.inTransaction() || isTransactionCommand(command);
+  const isRetryableWrite = !!options.willRetryWrite;
 
-  if (serverSession.txnNumber && (isRetryableWrite || inTransaction)) {
+  if (isRetryableWrite || inTxnOrTxnCommand) {
+    serverSession.txnNumber += session[kTxnNumberIncrement];
+    session[kTxnNumberIncrement] = 0;
     command.txnNumber = Long.fromNumber(serverSession.txnNumber);
   }
 
-  if (!inTransaction) {
+  if (!inTxnOrTxnCommand) {
     if (session.transaction.state !== TxnState.NO_TRANSACTION) {
       session.transaction.transition(TxnState.NO_TRANSACTION);
     }
@@ -1015,6 +1044,7 @@ export function applySession(
       Object.assign(command.readConcern, { afterClusterTime: session.operationTime });
     }
   }
+  return;
 }
 
 export function updateSessionFromResponse(session: ClientSession, document: Document): void {