@libp2p/http-utils 1.0.2 → 2.0.0

package/src/index.ts

@@ -7,18 +7,19 @@
 import { HTTPParser } from '@achingbrain/http-parser-js'
 import { InvalidParametersError, isPeerId, ProtocolError } from '@libp2p/interface'
 import { peerIdFromString } from '@libp2p/peer-id'
-import { isMultiaddr, multiaddr } from '@multiformats/multiaddr'
+import { getNetConfig } from '@libp2p/utils'
+import { CODE_P2P, isMultiaddr, multiaddr } from '@multiformats/multiaddr'
 import { multiaddrToUri } from '@multiformats/multiaddr-to-uri'
 import { uriToMultiaddr } from '@multiformats/uri-to-multiaddr'
-import { queuelessPushable } from 'it-queueless-pushable'
 import itToBrowserReadableStream from 'it-to-browser-readablestream'
 import { base36 } from 'multiformats/bases/base36'
 import { base64pad } from 'multiformats/bases/base64'
 import { sha1 } from 'multiformats/hashes/sha1'
+import { raceEvent } from 'race-event'
 import { Uint8ArrayList } from 'uint8arraylist'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { Request } from './request.js'
-import type { AbortOptions, PeerId, Stream } from '@libp2p/interface'
+import type { AbortOptions, PeerId, Stream, StreamMessageEvent } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 const DNS_CODECS = ['dns', 'dns4', 'dns6', 'dnsaddr']
@@ -89,10 +90,10 @@ export function streamToRequest (info: HeaderInfo, stream: Stream): globalThis.R
   }
 
   if ((init.method !== 'GET' || info.upgrade) && init.method !== 'HEAD') {
-    let source: AsyncGenerator<any> = stream.source
+    let source: AsyncIterable<any> = stream
 
     if (!info.upgrade) {
-      source = takeBytes(stream.source, info.headers.get('content-length'))
+      source = takeBytes(stream, info.headers.get('content-length'))
     }
 
     init.body = itToBrowserReadableStream<Uint8Array>(source)
@@ -104,13 +105,7 @@ export function streamToRequest (info: HeaderInfo, stream: Stream): globalThis.R
 }
 
 export async function responseToStream (res: Response, stream: Stream): Promise<void> {
-  const pushable = queuelessPushable<Uint8Array>()
-  stream.sink(pushable)
-    .catch(err => {
-      stream.abort(err)
-    })
-
-  await pushable.push(uint8ArrayFromString([
+  stream.send(uint8ArrayFromString([
     `HTTP/1.1 ${res.status} ${res.statusText}`,
     ...writeHeaders(res.headers),
     '',
@@ -118,28 +113,29 @@ export async function responseToStream (res: Response, stream: Stream): Promise<
   ].join('\r\n')))
 
   if (res.body == null) {
-    await pushable.end()
+    await stream.close().catch(err => {
+      stream.abort(err)
+    })
     return
   }
 
   const reader = res.body.getReader()
-  let result = await reader.read()
 
   while (true) {
+    const result = await reader.read()
+
     if (result.value != null) {
-      await pushable.push(result.value)
+      if (!stream.send(result.value)) {
+        await stream.onDrain()
+      }
     }
 
     if (result.done) {
       break
     }
-
-    result = await reader.read()
   }
 
-  await pushable.end()
-
-  await stream.closeWrite()
+  await stream.close()
     .catch(err => {
       stream.abort(err)
     })
@@ -187,7 +183,7 @@ export function writeHeaders (headers: Headers): string[] {
   return output
 }
 
-async function * takeBytes (source: AsyncGenerator<Uint8ArrayList>, bytes?: number | string | null): AsyncGenerator<Uint8Array> {
+async function * takeBytes (source: AsyncIterable<Uint8Array | Uint8ArrayList>, bytes?: number | string | null): AsyncGenerator<Uint8Array> {
   bytes = parseInt(`${bytes ?? ''}`)
 
   if (bytes == null || isNaN(bytes)) {
@@ -329,12 +325,16 @@ export function getHost (addresses: URL | Multiaddr[], headers: Headers): string
   // try to use remote PeerId as domain
   if (!isValidHost(host) && Array.isArray(addresses)) {
     for (const address of addresses) {
-      const peerStr = address.getPeerId()
+      const peerStr = address.getComponents()
+        .findLast(c => c.code === CODE_P2P)?.value
 
       // try to extract port from multiaddr if it is available
       try {
-        const options = address.toOptions()
-        port = options.port
+        const config = getNetConfig(address)
+
+        if (config.port != null) {
+          port = config.port
+        }
       } catch {}
 
       if (peerStr != null) {
@@ -350,9 +350,11 @@ export function getHost (addresses: URL | Multiaddr[], headers: Headers): string
   if (!isValidHost(host) && Array.isArray(addresses)) {
     for (const address of addresses) {
       try {
-        const options = address.toOptions()
+        const config = getNetConfig(address)
 
-        host = options.host
+        if (config.host != null) {
+          host = config.host
+        }
         break
       } catch {}
     }
@@ -490,55 +492,57 @@ export async function getServerUpgradeHeaders (headers: Headers | Record<string,
 /**
  * Reads HTTP headers from an incoming stream
  */
-export async function readHeaders (stream: Stream): Promise<HeaderInfo> {
-  return new Promise<any>((resolve, reject) => {
-    const parser = new HTTPParser('REQUEST')
-    const source = queuelessPushable<Uint8ArrayList>()
-    const earlyData = new Uint8ArrayList()
-    let headersComplete = false
-
-    parser[HTTPParser.kOnHeadersComplete] = (info) => {
-      headersComplete = true
-      const headers = new Headers()
-
-      // set incoming headers
-      for (let i = 0; i < info.headers.length; i += 2) {
-        headers.set(info.headers[i].toLowerCase(), info.headers[i + 1])
-      }
+export async function readHeaders (stream: Stream, options?: AbortOptions): Promise<HeaderInfo> {
+  const parser = new HTTPParser('REQUEST')
+  const earlyData = new Uint8ArrayList()
+  let headerInfo: HeaderInfo | undefined
 
-      resolve({
-        ...info,
-        headers,
-        raw: earlyData,
-        method: HTTPParser.methods[info.method]
-      })
+  parser[HTTPParser.kOnHeadersComplete] = (info) => {
+    const headers = new Headers()
+
+    // set incoming headers
+    for (let i = 0; i < info.headers.length; i += 2) {
+      headers.set(info.headers[i].toLowerCase(), info.headers[i + 1])
     }
 
-    // replace source with request body
-    const streamSource = stream.source
-    stream.source = source
-
-    Promise.resolve().then(async () => {
-      for await (const chunk of streamSource) {
-        // only use the message parser until the headers have been read
-        if (!headersComplete) {
-          earlyData.append(chunk)
-          parser.execute(chunk.subarray())
-        } else {
-          await source.push(new Uint8ArrayList(chunk))
-        }
+    headerInfo = {
+      ...info,
+      headers,
+      raw: earlyData,
+      method: HTTPParser.methods[info.method]
+    }
+  }
+
+  try {
+    while (true) {
+      const { data } = await raceEvent<StreamMessageEvent>(stream, 'message', options?.signal)
+      const buf = data.subarray()
+
+      const read = parser.execute(buf, 0, buf.byteLength)
+
+      if (read instanceof Error) {
+        throw read
       }
 
-      await source.end()
-    })
-      .catch((err: Error) => {
-        stream.abort(err)
-        reject(err)
-      })
-      .finally(() => {
-        parser.finish()
-      })
-  })
+      // collect raw header bytes
+      earlyData.append(buf.subarray(0, read))
+
+      if (read < buf.byteLength) {
+        // reading headers finished and we have early data
+        stream.push(buf.subarray(read))
+      }
+
+      if (headerInfo != null) {
+        return headerInfo
+      }
+    }
+  } catch (err: any) {
+    stream.abort(err)
+  } finally {
+    parser.finish()
+  }
+
+  throw new Error('Failed to read header info from request')
 }
 
 /**

package/src/stream-to-socket.ts

@@ -1,7 +1,5 @@
 import { Duplex } from 'node:stream'
-import { byteStream } from 'it-byte-stream'
-import type { Connection, Stream } from '@libp2p/interface'
-import type { ByteStream } from 'it-byte-stream'
+import type { Connection, Logger, Stream } from '@libp2p/interface'
 import type { Socket, SocketConnectOpts, AddressInfo, SocketReadyState } from 'node:net'
 
 const MAX_TIMEOUT = 2_147_483_647
@@ -16,96 +14,132 @@ export class Libp2pSocket extends Duplex {
   public timeout = MAX_TIMEOUT
   public allowHalfOpen: boolean
 
+  #initStream: Promise<Stream>
   #stream?: Stream
-  #bytes?: ByteStream<Stream>
 
-  constructor () {
+  #log?: Logger
+
+  constructor (stream: Stream, connection: Connection)
+  constructor (initStream: Promise<{ stream: Stream, connection: Connection }>)
+  constructor (...args: any[]) {
     super()
 
     this.bytesRead = 0
     this.bytesWritten = 0
     this.allowHalfOpen = true
     this.remoteAddress = ''
+
+    if (args.length === 2) {
+      this.gotStream({ stream: args[0], connection: args[1] })
+      this.#initStream = Promise.resolve(args[0])
+    } else {
+      this.#initStream = args[0].then(this.gotStream.bind(this), (err: any) => {
+        this.emit('error', err)
+        throw err
+      })
+    }
   }
 
-  setStream (stream: Stream, connection: Connection): void {
-    this.#bytes = byteStream(stream)
-    this.#stream = stream
+  private gotStream ({ stream, connection }: { stream: Stream, connection: Connection }): Stream {
+    this.#log = stream.log.newScope('libp2p-socket')
     this.remoteAddress = connection.remoteAddr.toString()
+
+    stream.addEventListener('message', (evt) => {
+      this.push(evt.data.subarray())
+    })
+
+    stream.addEventListener('close', (evt) => {
+      if (evt.error != null) {
+        this.destroy(evt.error)
+      } else {
+        this.push(null)
+      }
+    })
+
+    stream.pause()
+
+    this.emit('connect')
+
+    return stream
+  }
+
+  getStream (cb: (stream: Stream) => void): void {
+    if (this.#stream != null) {
+      cb(this.#stream)
+      return
+    }
+
+    this.#initStream.then(stream => {
+      this.#stream = stream
+      cb(stream)
+    }, (err) => {
+      this.emit('error', err)
+    })
+  }
+
+  destroy (error?: Error): this {
+    return super.destroy(error)
   }
 
   _write (chunk: Uint8Array, encoding: string, cb: (err?: Error) => void): void {
-    this.#stream?.log('write %d bytes', chunk.byteLength)
+    this.#log?.('write %d bytes', chunk.byteLength)
 
     this.bytesWritten += chunk.byteLength
-    this.#bytes?.write(chunk)
-      .then(() => {
+
+    this.getStream(stream => {
+      if (!stream.send(chunk)) {
+        stream.onDrain()
+          .then(() => {
+            cb()
+          }, (err) => {
+            cb(err)
+          })
+      } else {
         cb()
-      }, err => {
-        cb(err)
-      })
+      }
+    })
   }
 
   _read (size: number): void {
-    this.#stream?.log('asked to read %d bytes', size)
-
-    void Promise.resolve().then(async () => {
-      try {
-        while (true) {
-          const chunk = await this.#bytes?.read({
-            signal: AbortSignal.timeout(this.timeout)
-          })
-
-          if (chunk == null) {
-            this.#stream?.log('socket readable end closed')
-            this.push(null)
-            return
-          }
-
-          this.bytesRead += chunk.byteLength
+    this.#log?.('asked to read %d bytes', size)
+    this.getStream(stream => {
+      stream.resume()
+    })
+  }
 
-          this.#stream?.log('socket read %d bytes', chunk.byteLength)
-          const more = this.push(chunk.subarray())
+  _destroy (err: Error, cb: (err?: Error) => void): void {
+    this.#log?.('destroy with %d bytes buffered - %e', this.bufferSize, err)
 
-          if (!more) {
-            break
-          }
-        }
-      } catch (err: any) {
-        this.destroy(err)
+    this.getStream(stream => {
+      if (err != null) {
+        stream.abort(err)
+        cb()
+      } else {
+        stream.close()
+          .then(() => {
+            cb()
+          })
+          .catch(err => {
+            stream.abort(err)
+            cb(err)
+          })
       }
     })
   }
 
-  _destroy (err: Error, cb: (err?: Error) => void): void {
-    this.#stream?.log('destroy with %d bytes buffered - %e', this.bufferSize, err)
+  _final (cb: (err?: Error) => void): void {
+    this.#log?.('final')
 
-    if (err != null) {
-      this.#bytes?.unwrap().abort(err)
-      cb()
-    } else {
-      this.#bytes?.unwrap().close()
+    this.getStream(stream => {
+      stream.close()
         .then(() => {
           cb()
         })
         .catch(err => {
-          this.#stream?.abort(err)
+          stream.abort(err)
           cb(err)
         })
-    }
-  }
-
-  _final (cb: (err?: Error) => void): void {
-    this.#stream?.log('final')
-
-    this.#bytes?.unwrap().closeWrite()
-      .then(() => {
-        cb()
-      })
-      .catch(err => {
-        this.#bytes?.unwrap().abort(err)
-        cb(err)
-      })
+    })
   }
 
   public get readyState (): SocketReadyState {
@@ -129,7 +163,7 @@ export class Libp2pSocket extends Duplex {
   }
 
   destroySoon (): void {
-    this.#stream?.log('destroySoon with %d bytes buffered', this.bufferSize)
+    this.#log?.('destroySoon with %d bytes buffered', this.bufferSize)
     this.destroy()
   }
 
@@ -138,24 +172,27 @@ export class Libp2pSocket extends Duplex {
   connect (port: number, connectionListener?: () => void): this
   connect (path: string, connectionListener?: () => void): this
   connect (...args: any[]): this {
-    this.#stream?.log('connect %o', args)
+    this.#log?.('connect %o', args)
     return this
   }
 
   setEncoding (encoding?: BufferEncoding): this {
-    this.#stream?.log('setEncoding %s', encoding)
+    this.#log?.('setEncoding %s', encoding)
     return this
   }
 
   resetAndDestroy (): this {
-    this.#stream?.log('resetAndDestroy')
-    this.#stream?.abort(new Error('Libp2pSocket.resetAndDestroy'))
+    this.#log?.('resetAndDestroy')
+
+    this.getStream(stream => {
+      stream.abort(new Error('Libp2pSocket.resetAndDestroy'))
+    })
 
     return this
   }
 
   setTimeout (timeout: number, callback?: () => void): this {
-    this.#stream?.log('setTimeout %d', timeout)
+    this.#log?.('setTimeout %d', timeout)
 
     if (callback != null) {
       this.addListener('timeout', callback)
@@ -167,31 +204,31 @@ export class Libp2pSocket extends Duplex {
   }
 
   setNoDelay (noDelay?: boolean): this {
-    this.#stream?.log('setNoDelay %b', noDelay)
+    this.#log?.('setNoDelay %b', noDelay)
 
     return this
   }
 
   setKeepAlive (enable?: boolean, initialDelay?: number): this {
-    this.#stream?.log('setKeepAlive %b %d', enable, initialDelay)
+    this.#log?.('setKeepAlive %b %d', enable, initialDelay)
 
     return this
   }
 
   address (): AddressInfo | Record<string, any> {
-    this.#stream?.log('address')
+    this.#log?.('address')
 
     return {}
   }
 
   unref (): this {
-    this.#stream?.log('unref')
+    this.#log?.('unref')
 
     return this
   }
 
   ref (): this {
-    this.#stream?.log('ref')
+    this.#log?.('ref')
 
     return this
   }
@@ -204,8 +241,5 @@ export class Libp2pSocket extends Duplex {
 }
 
 export function streamToSocket (stream: Stream, connection: Connection): Socket {
-  const socket = new Libp2pSocket()
-  socket.setStream(stream, connection)
-
-  return socket
+  return new Libp2pSocket(stream, connection)
 }