@libp2p/http-utils 1.0.1 → 2.0.0

package/dist/typedoc-urls.json

@@ -3,6 +3,7 @@
   ".:Middleware": "https://libp2p.github.io/js-libp2p-http/interfaces/_libp2p_http-utils.Middleware.html",
   "MiddlewareOptions": "https://libp2p.github.io/js-libp2p-http/interfaces/_libp2p_http.index.MiddlewareOptions.html",
   ".:MiddlewareOptions": "https://libp2p.github.io/js-libp2p-http/interfaces/_libp2p_http-utils.MiddlewareOptions.html",
+  "Libp2pSocket": "https://libp2p.github.io/js-libp2p-http/classes/_libp2p_http-utils.Libp2pSocket.html",
   "Request": "https://libp2p.github.io/js-libp2p-http/classes/_libp2p_http-utils.Request.html",
   "Response": "https://libp2p.github.io/js-libp2p-http/classes/_libp2p_http-utils.Response.html",
   "HeaderInfo": "https://libp2p.github.io/js-libp2p-http/interfaces/_libp2p_http-utils.HeaderInfo.html",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@libp2p/http-utils",
-  "version": "1.0.1",
+  "version": "2.0.0",
   "description": "Shared utils and common code for HTTP modules",
   "license": "Apache-2.0 OR MIT",
   "homepage": "https://github.com/libp2p/js-libp2p-http/tree/main/packages/http-utils#readme",
@@ -139,21 +139,21 @@
   },
   "dependencies": {
     "@achingbrain/http-parser-js": "^0.5.9",
-    "@libp2p/interface": "^2.10.2",
-    "@libp2p/peer-id": "^5.1.5",
-    "@multiformats/multiaddr": "^12.4.0",
-    "@multiformats/multiaddr-to-uri": "^11.0.0",
-    "@multiformats/uri-to-multiaddr": "^9.0.1",
-    "it-byte-stream": "^2.0.2",
-    "it-queueless-pushable": "^2.0.1",
-    "it-to-browser-readablestream": "^2.0.11",
-    "multiformats": "^13.3.6",
+    "@libp2p/interface": "^3.0.2",
+    "@libp2p/peer-id": "^6.0.3",
+    "@libp2p/utils": "^7.0.4",
+    "@multiformats/multiaddr": "^13.0.1",
+    "@multiformats/multiaddr-to-uri": "^12.0.0",
+    "@multiformats/uri-to-multiaddr": "^10.0.0",
+    "it-to-browser-readablestream": "^2.0.12",
+    "multiformats": "^13.4.1",
+    "race-event": "^1.6.1",
     "readable-stream": "^4.7.0",
     "uint8arraylist": "^2.4.8",
     "uint8arrays": "^5.1.0"
   },
   "devDependencies": {
-    "aegir": "^47.0.16"
+    "aegir": "^47.0.22"
   },
   "browser": {
     "node:stream": "readable-stream"

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,115 +1,157 @@
 import { Duplex } from 'node:stream'
-import { byteStream } from 'it-byte-stream'
-import type { Connection, Stream } from '@libp2p/interface'
+import type { Connection, Logger, Stream } from '@libp2p/interface'
 import type { Socket, SocketConnectOpts, AddressInfo, SocketReadyState } from 'node:net'
 
 const MAX_TIMEOUT = 2_147_483_647
 
-class Libp2pSocket extends Duplex {
+export class Libp2pSocket extends Duplex {
   public readonly autoSelectFamilyAttemptedAddresses = []
   public readonly connecting = false
   public readonly pending = false
-  public readonly remoteAddress: string
+  public remoteAddress: string
   public bytesRead: number
   public bytesWritten: number
   public timeout = MAX_TIMEOUT
   public allowHalfOpen: boolean
 
-  private readonly stream: Stream
+  #initStream: Promise<Stream>
+  #stream?: Stream
 
-  constructor (stream: Stream, connection: Connection) {
-    const bytes = byteStream(stream)
+  #log?: Logger
 
-    super({
-      write: (chunk, encoding, cb) => {
-        this.stream.log('write %d bytes', chunk.byteLength)
+  constructor (stream: Stream, connection: Connection)
+  constructor (initStream: Promise<{ stream: Stream, connection: Connection }>)
+  constructor (...args: any[]) {
+    super()
 
-        this.bytesWritten += chunk.byteLength
-        bytes.write(chunk)
+    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
+      })
+    }
+  }
+
+  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.#log?.('write %d bytes', chunk.byteLength)
+
+    this.bytesWritten += chunk.byteLength
+
+    this.getStream(stream => {
+      if (!stream.send(chunk)) {
+        stream.onDrain()
           .then(() => {
             cb()
-          }, err => {
+          }, (err) => {
             cb(err)
           })
-      },
-      read: (size) => {
-        this.stream.log('asked to read %d bytes', size)
-
-        void Promise.resolve().then(async () => {
-          try {
-            while (true) {
-              const chunk = await 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.stream.log('socket read %d bytes', chunk.byteLength)
-              const more = this.push(chunk.subarray())
-
-              if (!more) {
-                break
-              }
-            }
-          } catch (err: any) {
-            this.destroy(err)
-          }
-        })
-      },
-      destroy: (err, cb) => {
-        this.stream.log('destroy with %d bytes buffered - %e', this.bufferSize, err)
+      } else {
+        cb()
+      }
+    })
+  }
 
-        if (err != null) {
-          bytes.unwrap().abort(err)
-          cb()
-        } else {
-          bytes.unwrap().close()
-            .then(() => {
-              cb()
-            })
-            .catch(err => {
-              stream.abort(err)
-              cb(err)
-            })
-        }
-      },
-      final: (cb) => {
-        this.stream.log('final')
-
-        bytes.unwrap().closeWrite()
+  _read (size: number): void {
+    this.#log?.('asked to read %d bytes', size)
+    this.getStream(stream => {
+      stream.resume()
+    })
+  }
+
+  _destroy (err: Error, cb: (err?: Error) => void): void {
+    this.#log?.('destroy with %d bytes buffered - %e', this.bufferSize, err)
+
+    this.getStream(stream => {
+      if (err != null) {
+        stream.abort(err)
+        cb()
+      } else {
+        stream.close()
           .then(() => {
             cb()
           })
           .catch(err => {
-            bytes.unwrap().abort(err)
+            stream.abort(err)
             cb(err)
           })
       }
     })
+  }
 
-    this.stream = stream
-    this.remoteAddress = connection.remoteAddr.toString()
-    this.bytesRead = 0
-    this.bytesWritten = 0
-    this.allowHalfOpen = true
+  _final (cb: (err?: Error) => void): void {
+    this.#log?.('final')
+
+    this.getStream(stream => {
+      stream.close()
+        .then(() => {
+          cb()
+        })
+        .catch(err => {
+          stream.abort(err)
+          cb(err)
+        })
+    })
   }
 
   public get readyState (): SocketReadyState {
-    if (this.stream.status === 'closed') {
+    if (this.#stream?.status === 'closed') {
       return 'closed'
     }
 
-    if (this.stream.writeStatus === 'closed' || this.stream.writeStatus === 'closing') {
+    if (this.#stream?.writeStatus === 'closed' || this.#stream?.writeStatus === 'closing') {
       return 'readOnly'
     }
 
-    if (this.stream.readStatus === 'closed' || this.stream.readStatus === 'closing') {
+    if (this.#stream?.readStatus === 'closed' || this.#stream?.readStatus === 'closing') {
       return 'writeOnly'
     }
 
@@ -121,7 +163,7 @@ 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()
   }
 
@@ -130,24 +172,27 @@ 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)
@@ -159,31 +204,31 @@ 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
   }