Method _close

src/mongo_client.ts:758–822

()

  /* @internal */
  private async _close(): Promise<void> {
    // There's no way to set hasBeenClosed back to false
    Object.defineProperty(this.s, 'hasBeenClosed', {
      value: true,
      enumerable: true,
      configurable: false,
      writable: false
    });

    this.topology?.closeCheckedOutConnections();

    const activeCursorCloses = Array.from(this.s.activeCursors, cursor => cursor.close());
    this.s.activeCursors.clear();

    await Promise.all(activeCursorCloses);

    const activeSessionEnds = Array.from(this.s.activeSessions, session => session.endSession());
    this.s.activeSessions.clear();

    await Promise.all(activeSessionEnds);

    if (this.topology == null) {
      return;
    }

    const supportsSessions =
      this.topology.description.type === TopologyType.LoadBalanced ||
      this.topology.description.logicalSessionTimeoutMinutes != null;

    if (supportsSessions) {
      await endSessions(this, this.topology);
    }

    // clear out references to old topology
    const topology = this.topology;
    this.topology = undefined;

    topology.close();

    const { encrypter } = this.options;
    if (encrypter) {
      await encrypter.close(this);
    }

    async function endSessions(
      client: MongoClient,
      { description: topologyDescription }: Topology
    ) {
      // If we would attempt to select a server and get nothing back we short circuit
      // to avoid the server selection timeout.
      const selector = readPreferenceServerSelector(ReadPreference.primaryPreferred);
      const serverDescriptions = Array.from(topologyDescription.servers.values());
      const servers = selector(topologyDescription, serverDescriptions, new DeprioritizedServers());
      if (servers.length !== 0) {
        const endSessions = Array.from(client.s.sessionPool.sessions, ({ id }) => id);
        if (endSessions.length !== 0) {
          try {
            await executeOperation(client, new EndSessionsOperation(endSessions));