Method end

lib/internal/quic/quic.js:2257–2293

(options = kEmptyObject)

    }

    async function end(options = kEmptyObject) {
      validateObject(options, 'options');
      const { signal } = options;
      if (signal !== undefined) {
        validateAbortSignal(signal, 'options.signal');
        signal.throwIfAborted();
        // TODO(@jasnell): The stream/iter spec allows individual sync end
        // calls to be canceled via an AbortSignal. We currently do not support
        // this, but we can add before the impl is graduated from experimental.
        // At most we do here is check for signal abort at the start of the call.
      }

      // Per the streams/iter spec, endSync and end follow a try-fallback
      // pattern. That is, callers should try endSync first and if it returns
      // -1, then they should call and await end(). This is a signal that sync
      // end is not currently possible. However, we always support sync end
      // here unless the stream is already errored.
      // While the user should have already called endSync, we call it again
      // here to actually process the end request. At worst it's called twice.
      const n = endSync();

      // A return value of -1 indicates that endSync was not yet able to
      // process the end request, either because we are errored or because we
      // are awaiting drain. If we're errored, throw the error. If we're waiting
      // for drain, await it and then try ending again.

      if (n >= 0) return n;
      if (errored) throw error;

      drainWakeup ??= PromiseWithResolvers();
      try {
        await drainWakeup.promise;
      } finally {
        drainWakeup = null;
      }
      return endSync();
    }

    function fail(reason) {
      if (closed || errored) return;