Method destroy

lib/internal/quic/quic.js:3513–3648

* Forcefully closes the session abruptly without waiting for streams to be * completed naturally. Any streams that are still open will be immediately * destroyed and any queued datagrams will be dropped. If an error is given, * the closed promise will be rejected with that error. If no erro

(error, options)

   *   string included in the CONNECTION_CLOSE frame (diagnostic only).
   */
  destroy(error, options) {
    assertIsQuicSession(this);
    const inner = this.#inner;
    // Two distinct guards (see also `QuicStream.destroy`):
    //   * `#destroying` flips synchronously here so any re-entrant call
    //     (e.g. from a user `onerror` callback or from a cascading
    //     `stream.destroy(error)` whose own `onerror` re-enters
    //     `session.destroy()`) hits this guard and returns immediately
    //     without running the teardown twice.
    //   * `destroyed` (i.e. `#handle === undefined`) signals
    //     "fully torn down". Defense-in-depth for paths that may have
    //     finished teardown without setting `#destroying` and for
    //     repeat invocations after this method has fully run.
    if (inner.destroying || this.destroyed) return;

    if (options !== undefined) options = validateCloseOptions(options);
    inner.destroying = true;

    debug('destroying the session');

    if (error !== undefined) {
      if (onSessionErrorChannel.hasSubscribers) {
        onSessionErrorChannel.publish({
          __proto__: null,
          session: this,
          error,
        });
      }
      if (typeof inner.onerror === 'function') {
        invokeOnerror(inner.onerror, error);
      }
    }

    // First, forcefully and immediately destroy all open streams, if any.
    for (const stream of inner.streams) {
      stream.destroy(error);
    }
    // The streams should remove themselves when they are destroyed but let's
    // be doubly sure.
    if (inner.streams.size) {
      process.emitWarning(
        `The session is destroyed with ${inner.streams.size} active streams. ` +
        'This should not happen and indicates a bug in Node.js. Please open an ' +
        'issue in the Node.js GitHub repository at https://github.com/nodejs/node ' +
        'to report the problem.',
      );
    }
    inner.streams.clear();

    // Remove this session immediately from the endpoint
    inner.endpoint[kRemoveSession](this);
    inner.endpoint = undefined;
    inner.isPendingClose = false;

    // If the handshake never completed, reject the opened promise. The
    // session is being destroyed, so the handshake will never complete
    // and `await session.opened` would otherwise hang forever. The
    // documented contract is that opened rejects when the session is