undici 7.0.0-alpha.2 → 7.0.0-alpha.3

package/lib/core/util.js

@@ -10,7 +10,7 @@ const nodeUtil = require('node:util')
 const { stringify } = require('node:querystring')
 const { EventEmitter: EE } = require('node:events')
 const { InvalidArgumentError } = require('./errors')
-const { headerNameLowerCasedRecord } = require('./constants')
+const { headerNameLowerCasedRecord, getHeaderNameAsBuffer } = require('./constants')
 const { tree } = require('./tree')
 
 const [nodeMajor, nodeMinor] = process.versions.node.split('.').map(v => Number(v))
@@ -436,6 +436,44 @@ function parseHeaders (headers, obj) {
   return obj
 }
 
+/**
+ * @param {Record<string, string | string[]>} headers
+ * @returns {(Buffer | Buffer[])[]}
+ */
+function encodeHeaders (headers) {
+  const headerNames = Object.keys(headers)
+
+  /**
+   * @type {Buffer[]|Buffer[][]}
+   */
+  const rawHeaders = new Array(headerNames.length * 2)
+
+  let rawHeadersIndex = 0
+  for (const header of headerNames) {
+    let rawValue
+    const value = headers[header]
+    if (Array.isArray(value)) {
+      rawValue = new Array(value.length)
+
+      for (let i = 0; i < value.length; i++) {
+        rawValue[i] = Buffer.from(value[i])
+      }
+    } else {
+      rawValue = Buffer.from(value)
+    }
+
+    const headerBuffer = getHeaderNameAsBuffer(header)
+
+    rawHeaders[rawHeadersIndex] = headerBuffer
+    rawHeadersIndex++
+
+    rawHeaders[rawHeadersIndex] = rawValue
+    rawHeadersIndex++
+  }
+
+  return rawHeaders
+}
+
 /**
  * @param {Buffer[]} headers
  * @returns {string[]}
@@ -864,6 +902,7 @@ module.exports = {
   errorRequest,
   parseRawHeaders,
   parseHeaders,
+  encodeHeaders,
   parseKeepAliveTimeout,
   destroy,
   bodyLength,
@@ -885,6 +924,6 @@ module.exports = {
   isHttpOrHttpsPrefixed,
   nodeMajor,
   nodeMinor,
-  safeHTTPMethods: ['GET', 'HEAD', 'OPTIONS', 'TRACE'],
+  safeHTTPMethods: Object.freeze(['GET', 'HEAD', 'OPTIONS', 'TRACE']),
   wrapRequestBody
 }

package/lib/dispatcher/client-h1.js

@@ -49,13 +49,13 @@ const {
   kMaxResponseSize,
   kOnError,
   kResume,
-  kHTTPContext
+  kHTTPContext,
+  kClosed
 } = require('../core/symbols.js')
 
 const constants = require('../llhttp/constants.js')
 const EMPTY_BUF = Buffer.alloc(0)
 const FastBuffer = Buffer[Symbol.species]
-const addListener = util.addListener
 const removeAllListeners = util.removeAllListeners
 
 let extractBody
@@ -779,87 +779,13 @@ async function connectH1 (client, socket) {
   socket[kBlocking] = false
   socket[kParser] = new Parser(client, socket, llhttpInstance)
 
-  addListener(socket, 'error', function (err) {
-    assert(err.code !== 'ERR_TLS_CERT_ALTNAME_INVALID')
+  util.addListener(socket, 'error', onHttpSocketError)
+  util.addListener(socket, 'readable', onHttpSocketReadable)
+  util.addListener(socket, 'end', onHttpSocketEnd)
+  util.addListener(socket, 'close', onHttpSocketClose)
 
-    const parser = this[kParser]
-
-    // On Mac OS, we get an ECONNRESET even if there is a full body to be forwarded
-    // to the user.
-    if (err.code === 'ECONNRESET' && parser.statusCode && !parser.shouldKeepAlive) {
-      // We treat all incoming data so for as a valid response.
-      parser.onMessageComplete()
-      return
-    }
-
-    this[kError] = err
-
-    this[kClient][kOnError](err)
-  })
-  addListener(socket, 'readable', function () {
-    this[kParser]?.readMore()
-  })
-  addListener(socket, 'end', function () {
-    const parser = this[kParser]
-
-    if (parser.statusCode && !parser.shouldKeepAlive) {
-      // We treat all incoming data so far as a valid response.
-      parser.onMessageComplete()
-      return
-    }
-
-    util.destroy(this, new SocketError('other side closed', util.getSocketInfo(this)))
-  })
-  addListener(socket, 'close', function () {
-    const parser = this[kParser]
-
-    if (parser) {
-      if (!this[kError] && parser.statusCode && !parser.shouldKeepAlive) {
-        // We treat all incoming data so far as a valid response.
-        parser.onMessageComplete()
-      }
-
-      this[kParser].destroy()
-      this[kParser] = null
-    }
-
-    const err = this[kError] || new SocketError('closed', util.getSocketInfo(this))
-
-    const client = this[kClient]
-
-    client[kSocket] = null
-    client[kHTTPContext] = null // TODO (fix): This is hacky...
-
-    if (client.destroyed) {
-      assert(client[kPending] === 0)
-
-      // Fail entire queue.
-      const requests = client[kQueue].splice(client[kRunningIdx])
-      for (let i = 0; i < requests.length; i++) {
-        const request = requests[i]
-        util.errorRequest(client, request, err)
-      }
-    } else if (client[kRunning] > 0 && err.code !== 'UND_ERR_INFO') {
-      // Fail head of pipeline.
-      const request = client[kQueue][client[kRunningIdx]]
-      client[kQueue][client[kRunningIdx]++] = null
-
-      util.errorRequest(client, request, err)
-    }
-
-    client[kPendingIdx] = client[kRunningIdx]
-
-    assert(client[kRunning] === 0)
-
-    client.emit('disconnect', client[kUrl], [client], err)
-
-    client[kResume]()
-  })
-
-  let closed = false
-  socket.on('close', () => {
-    closed = true
-  })
+  socket[kClosed] = false
+  socket.on('close', onSocketClose)
 
   return {
     version: 'h1',
@@ -875,7 +801,7 @@ async function connectH1 (client, socket) {
      * @param {() => void} callback
      */
     destroy (err, callback) {
-      if (closed) {
+      if (socket[kClosed]) {
         queueMicrotask(callback)
       } else {
         socket.on('close', callback)
@@ -931,6 +857,90 @@ async function connectH1 (client, socket) {
   }
 }
 
+function onHttpSocketError (err) {
+  assert(err.code !== 'ERR_TLS_CERT_ALTNAME_INVALID')
+
+  const parser = this[kParser]
+
+  // On Mac OS, we get an ECONNRESET even if there is a full body to be forwarded
+  // to the user.
+  if (err.code === 'ECONNRESET' && parser.statusCode && !parser.shouldKeepAlive) {
+    // We treat all incoming data so for as a valid response.
+    parser.onMessageComplete()
+    return
+  }
+
+  this[kError] = err
+
+  this[kClient][kOnError](err)
+}
+
+function onHttpSocketReadable () {
+  this[kParser]?.readMore()
+}
+
+function onHttpSocketEnd () {
+  const parser = this[kParser]
+
+  if (parser.statusCode && !parser.shouldKeepAlive) {
+    // We treat all incoming data so far as a valid response.
+    parser.onMessageComplete()
+    return
+  }
+
+  util.destroy(this, new SocketError('other side closed', util.getSocketInfo(this)))
+}
+
+function onHttpSocketClose () {
+  const parser = this[kParser]
+
+  if (parser) {
+    if (!this[kError] && parser.statusCode && !parser.shouldKeepAlive) {
+      // We treat all incoming data so far as a valid response.
+      parser.onMessageComplete()
+    }
+
+    this[kParser].destroy()
+    this[kParser] = null
+  }
+
+  const err = this[kError] || new SocketError('closed', util.getSocketInfo(this))
+
+  const client = this[kClient]
+
+  client[kSocket] = null
+  client[kHTTPContext] = null // TODO (fix): This is hacky...
+
+  if (client.destroyed) {
+    assert(client[kPending] === 0)
+
+    // Fail entire queue.
+    const requests = client[kQueue].splice(client[kRunningIdx])
+    for (let i = 0; i < requests.length; i++) {
+      const request = requests[i]
+      util.errorRequest(client, request, err)
+    }
+  } else if (client[kRunning] > 0 && err.code !== 'UND_ERR_INFO') {
+    // Fail head of pipeline.
+    const request = client[kQueue][client[kRunningIdx]]
+    client[kQueue][client[kRunningIdx]++] = null
+
+    util.errorRequest(client, request, err)
+  }
+
+  client[kPendingIdx] = client[kRunningIdx]
+
+  assert(client[kRunning] === 0)
+
+  client.emit('disconnect', client[kUrl], [client], err)
+
+  client[kResume]()
+}
+
+function onSocketClose () {
+  this[kClosed] = true
+}
+
 /**
  * @param {import('./client.js')} client
  */
@@ -991,7 +1001,10 @@ function writeH1 (client, request) {
   const expectsPayload = (
     method === 'PUT' ||
     method === 'POST' ||
-    method === 'PATCH'
+    method === 'PATCH' ||
+    method === 'QUERY' ||
+    method === 'PROPFIND' ||
+    method === 'PROPPATCH'
   )
 
   if (util.isFormDataLike(body)) {
@@ -1319,7 +1332,7 @@ function writeBuffer (abort, body, client, request, socket, contentLength, heade
       socket.uncork()
       request.onBodySent(body)
 
-      if (!expectsPayload) {
+      if (!expectsPayload && request.reset !== false) {
         socket[kReset] = true
       }
     }
@@ -1360,7 +1373,7 @@ async function writeBlob (abort, body, client, request, socket, contentLength, h
     request.onBodySent(buffer)
     request.onRequestSent()
 
-    if (!expectsPayload) {
+    if (!expectsPayload && request.reset !== false) {
       socket[kReset] = true
     }
 
@@ -1487,7 +1500,7 @@ class AsyncWriter {
     socket.cork()
 
     if (bytesWritten === 0) {
-      if (!expectsPayload) {
+      if (!expectsPayload && request.reset !== false) {
         socket[kReset] = true
       }
 

package/lib/dispatcher/client-h2.js

@@ -24,7 +24,10 @@ const {
   kOnError,
   kMaxConcurrentStreams,
   kHTTP2Session,
-  kResume
+  kResume,
+  kSize,
+  kHTTPContext,
+  kClosed
 } = require('../core/symbols.js')
 
 const kOpenStreams = Symbol('open streams')
@@ -91,83 +94,37 @@ async function connectH2 (client, socket) {
   session[kOpenStreams] = 0
   session[kClient] = client
   session[kSocket] = socket
+  session[kHTTP2Session] = null
 
   util.addListener(session, 'error', onHttp2SessionError)
   util.addListener(session, 'frameError', onHttp2FrameError)
   util.addListener(session, 'end', onHttp2SessionEnd)
-  util.addListener(session, 'goaway', onHTTP2GoAway)
-  util.addListener(session, 'close', function () {
-    const { [kClient]: client } = this
-    const { [kSocket]: socket } = client
-
-    const err = this[kSocket][kError] || this[kError] || new SocketError('closed', util.getSocketInfo(socket))
-
-    client[kHTTP2Session] = null
-
-    if (client.destroyed) {
-      assert(client[kPending] === 0)
-
-      // Fail entire queue.
-      const requests = client[kQueue].splice(client[kRunningIdx])
-      for (let i = 0; i < requests.length; i++) {
-        const request = requests[i]
-        util.errorRequest(client, request, err)
-      }
-    }
-  })
+  util.addListener(session, 'goaway', onHttp2SessionGoAway)
+  util.addListener(session, 'close', onHttp2SessionClose)
 
   session.unref()
 
   client[kHTTP2Session] = session
   socket[kHTTP2Session] = session
 
-  util.addListener(socket, 'error', function (err) {
-    assert(err.code !== 'ERR_TLS_CERT_ALTNAME_INVALID')
+  util.addListener(socket, 'error', onHttp2SocketError)
+  util.addListener(socket, 'end', onHttp2SocketEnd)
+  util.addListener(socket, 'close', onHttp2SocketClose)
 
-    this[kError] = err
-
-    this[kClient][kOnError](err)
-  })
-
-  util.addListener(socket, 'end', function () {
-    util.destroy(this, new SocketError('other side closed', util.getSocketInfo(this)))
-  })
-
-  util.addListener(socket, 'close', function () {
-    const err = this[kError] || new SocketError('closed', util.getSocketInfo(this))
-
-    client[kSocket] = null
-
-    if (this[kHTTP2Session] != null) {
-      this[kHTTP2Session].destroy(err)
-    }
-
-    client[kPendingIdx] = client[kRunningIdx]
-
-    assert(client[kRunning] === 0)
-
-    client.emit('disconnect', client[kUrl], [client], err)
-
-    client[kResume]()
-  })
-
-  let closed = false
-  socket.on('close', () => {
-    closed = true
-  })
+  socket[kClosed] = false
+  socket.on('close', onSocketClose)
 
   return {
     version: 'h2',
     defaultPipelining: Infinity,
-    write (...args) {
-      // TODO (fix): return
-      writeH2(client, ...args)
+    write (request) {
+      return writeH2(client, request)
     },
     resume () {
-
+      resumeH2(client)
     },
     destroy (err, callback) {
-      if (closed) {
+      if (socket[kClosed]) {
         queueMicrotask(callback)
       } else {
         // Destroying the socket will trigger the session close
@@ -183,6 +140,20 @@ async function connectH2 (client, socket) {
   }
 }
 
+function resumeH2 (client) {
+  const socket = client[kSocket]
+
+  if (socket?.destroyed === false) {
+    if (client[kSize] === 0 && client[kMaxConcurrentStreams] === 0) {
+      socket.unref()
+      client[kHTTP2Session].unref()
+    } else {
+      socket.ref()
+      client[kHTTP2Session].ref()
+    }
+  }
+}
+
 function onHttp2SessionError (err) {
   assert(err.code !== 'ERR_TLS_CERT_ALTNAME_INVALID')
 
@@ -208,19 +179,93 @@ function onHttp2SessionEnd () {
  * This is the root cause of #3011
  * We need to handle GOAWAY frames properly, and trigger the session close
  * along with the socket right away
+ *
+ * @this {import('http2').ClientHttp2Session}
+ * @param {number} errorCode
  */
-function onHTTP2GoAway (code) {
-  const err = new RequestAbortedError(`HTTP/2: "GOAWAY" frame received with code ${code}`)
+function onHttp2SessionGoAway (errorCode) {
+  // We cannot recover, so best to close the session and the socket
+  const err = this[kError] || new SocketError(`HTTP/2: "GOAWAY" frame received with code ${errorCode}`, util.getSocketInfo(this[kSocket]))
+  const client = this[kClient]
 
-  // We need to trigger the close cycle right away
-  // We need to destroy the session and the socket
-  // Requests should be failed with the error after the current one is handled
-  this[kSocket][kError] = err
-  this[kClient][kOnError](err)
+  client[kSocket] = null
+  client[kHTTPContext] = null
 
-  this.unref()
+  if (this[kHTTP2Session] !== null) {
+    this[kHTTP2Session].destroy(err)
+    this[kHTTP2Session] = null
+  }
 
   util.destroy(this[kSocket], err)
+
+  // Fail head of pipeline.
+  const request = client[kQueue][client[kRunningIdx]]
+  client[kQueue][client[kRunningIdx]++] = null
+  util.errorRequest(client, request, err)
+
+  client[kPendingIdx] = client[kRunningIdx]
+
+  assert(client[kRunning] === 0)
+
+  client.emit('disconnect', client[kUrl], [client], err)
+
+  client[kResume]()
+}
+
+function onHttp2SessionClose () {
+  const { [kClient]: client } = this
+  const { [kSocket]: socket } = client
+
+  const err = this[kSocket][kError] || this[kError] || new SocketError('closed', util.getSocketInfo(socket))
+
+  client[kHTTP2Session] = null
+
+  if (client.destroyed) {
+    assert(client[kPending] === 0)
+
+    // Fail entire queue.
+    const requests = client[kQueue].splice(client[kRunningIdx])
+    for (let i = 0; i < requests.length; i++) {
+      const request = requests[i]
+      util.errorRequest(client, request, err)
+    }
+  }
+}
+
+function onHttp2SocketClose () {
+  const err = this[kError] || new SocketError('closed', util.getSocketInfo(this))
+
+  const client = this[kHTTP2Session][kClient]
+
+  client[kSocket] = null
+
+  if (this[kHTTP2Session] !== null) {
+    this[kHTTP2Session].destroy(err)
+  }
+
+  client[kPendingIdx] = client[kRunningIdx]
+
+  assert(client[kRunning] === 0)
+
+  client.emit('disconnect', client[kUrl], [client], err)
+
+  client[kResume]()
+}
+
+function onHttp2SocketError (err) {
+  assert(err.code !== 'ERR_TLS_CERT_ALTNAME_INVALID')
+
+  this[kError] = err
+
+  this[kClient][kOnError](err)
+}
+
+function onHttp2SocketEnd () {
+  util.destroy(this, new SocketError('other side closed', util.getSocketInfo(this)))
+}
+
+function onSocketClose () {
+  this[kClosed] = true
 }
 
 // https://www.rfc-editor.org/rfc/rfc7230#section-3.3.2
@@ -237,10 +282,6 @@ function writeH2 (client, request) {
     return false
   }
 
-  if (request.aborted) {
-    return false
-  }
-
   const headers = {}
   for (let n = 0; n < reqHeaders.length; n += 2) {
     const key = reqHeaders[n + 0]
@@ -283,6 +324,8 @@ function writeH2 (client, request) {
     // We do not destroy the socket as we can continue using the session
     // the stream gets destroyed and the session remains to create new streams
     util.destroy(body, err)
+    client[kQueue][client[kRunningIdx]++] = null
+    client[kResume]()
   }
 
   try {
@@ -293,6 +336,10 @@ function writeH2 (client, request) {
     util.errorRequest(client, request, err)
   }
 
+  if (request.aborted) {
+    return false
+  }
+
   if (method === 'CONNECT') {
     session.ref()
     // We are already connected, streams are pending, first request
@@ -304,10 +351,12 @@ function writeH2 (client, request) {
     if (stream.id && !stream.pending) {
       request.onUpgrade(null, null, stream)
       ++session[kOpenStreams]
+      client[kQueue][client[kRunningIdx]++] = null
     } else {
       stream.once('ready', () => {
         request.onUpgrade(null, null, stream)
         ++session[kOpenStreams]
+        client[kQueue][client[kRunningIdx]++] = null
       })
     }
 
@@ -428,17 +477,20 @@ function writeH2 (client, request) {
     // Present specially when using pipeline or stream
     if (stream.state?.state == null || stream.state.state < 6) {
       request.onComplete([])
-      return
     }
 
-    // Stream is closed or half-closed-remote (6), decrement counter and cleanup
-    // It does not have sense to continue working with the stream as we do not
-    // have yet RST_STREAM support on client-side
     if (session[kOpenStreams] === 0) {
+      // Stream is closed or half-closed-remote (6), decrement counter and cleanup
+      // It does not have sense to continue working with the stream as we do not
+      // have yet RST_STREAM support on client-side
+
       session.unref()
     }
 
     abort(new InformationalError('HTTP/2: stream half-closed (remote)'))
+    client[kQueue][client[kRunningIdx]++] = null
+    client[kPendingIdx] = client[kRunningIdx]
+    client[kResume]()
   })
 
   stream.once('close', () => {

package/lib/dispatcher/pool-base.js

@@ -113,9 +113,9 @@ class PoolBase extends DispatcherBase {
 
   async [kClose] () {
     if (this[kQueue].isEmpty()) {
-      return Promise.all(this[kClients].map(c => c.close()))
+      await Promise.all(this[kClients].map(c => c.close()))
     } else {
-      return new Promise((resolve) => {
+      await new Promise((resolve) => {
         this[kClosedResolve] = resolve
       })
     }
@@ -130,7 +130,7 @@ class PoolBase extends DispatcherBase {
       item.handler.onError(err)
     }
 
-    return Promise.all(this[kClients].map(c => c.destroy(err)))
+    await Promise.all(this[kClients].map(c => c.destroy(err)))
   }
 
   [kDispatch] (opts, handler) {