@libp2p/webtransport 3.0.10 → 3.0.11-6cb80f7d

package/src/index.ts

@@ -7,13 +7,14 @@ import { inertDuplex } from './utils/inert-duplex.js'
 import { isSubset } from './utils/is-subset.js'
 import { parseMultiaddr } from './utils/parse-multiaddr.js'
 import type { Connection, MultiaddrConnection, Stream } from '@libp2p/interface/connection'
+import type { CounterGroup, Metrics } from '@libp2p/interface/metrics'
 import type { PeerId } from '@libp2p/interface/peer-id'
 import type { StreamMuxerFactory, StreamMuxerInit, StreamMuxer } from '@libp2p/interface/stream-muxer'
 import type { Source } from 'it-stream-types'
 import type { MultihashDigest } from 'multiformats/hashes/interface'
 
 interface WebTransportSessionCleanup {
-  (closeInfo?: WebTransportCloseInfo): void
+  (metric: string): void
 }
 
 const log = logger('libp2p:webtransport')
@@ -24,17 +25,32 @@ export interface WebTransportInit {
 
 export interface WebTransportComponents {
   peerId: PeerId
+  metrics?: Metrics
+}
+
+export interface WebTransportMetrics {
+  dialerEvents: CounterGroup
 }
 
 class WebTransportTransport implements Transport {
   private readonly components: WebTransportComponents
   private readonly config: Required<WebTransportInit>
+  private readonly metrics?: WebTransportMetrics
 
   constructor (components: WebTransportComponents, init: WebTransportInit = {}) {
     this.components = components
     this.config = {
       maxInboundStreams: init.maxInboundStreams ?? 1000
     }
+
+    if (components.metrics != null) {
+      this.metrics = {
+        dialerEvents: components.metrics.registerCounterGroup('libp2p_webtransport_dialer_events_total', {
+          label: 'event',
+          help: 'Total count of WebTransport dialer events by type'
+        })
+      }
+    }
   }
 
   readonly [Symbol.toStringTag] = '@libp2p/webtransport'
@@ -65,10 +81,15 @@ class WebTransportTransport implements Transport {
     let abortListener: (() => void) | undefined
     let maConn: MultiaddrConnection | undefined
 
-    let cleanUpWTSession: (closeInfo?: WebTransportCloseInfo) => void = () => {}
+    let cleanUpWTSession: WebTransportSessionCleanup = () => {}
+
+    let closed = false
+    let ready = false
+    let authenticated = false
 
     try {
-      let closed = false
+      this.metrics?.dialerEvents.increment({ pending: true })
+
       const wt = new WebTransport(`${url}/.well-known/libp2p-webtransport?type=noise`, {
         serverCertificateHashes: certhashes.map(certhash => ({
           algorithm: 'sha-256',
@@ -76,74 +97,69 @@ class WebTransportTransport implements Transport {
         }))
       })
 
-      cleanUpWTSession = (closeInfo?: WebTransportCloseInfo) => {
+      cleanUpWTSession = (metric: string) => {
+        if (closed) {
+          // already closed session
+          return
+        }
+
         try {
+          this.metrics?.dialerEvents.increment({ [metric]: true })
+          wt.close()
+        } catch (err) {
+          log.error('error closing wt session', err)
+        } finally {
+          // This is how we specify the connection is closed and shouldn't be used.
           if (maConn != null) {
-            if (maConn.timeline.close != null) {
-              // already closed session
-              return
-            }
-
-            // This is how we specify the connection is closed and shouldn't be used.
             maConn.timeline.close = Date.now()
           }
 
-          if (closed) {
-            // already closed session
-            return
-          }
-
-          wt.close(closeInfo)
-        } catch (err) {
-          log.error('error closing wt session', err)
-        } finally {
           closed = true
         }
       }
 
-      // this promise resolves/throws when the session is closed or failed to init
-      wt.closed
-        .then(async () => {
-          await maConn?.close()
-        })
-        .catch((err: Error) => {
-          log.error('error on remote wt session close', err)
-          maConn?.abort(err)
-        })
-        .finally(() => {
-          // if we never got as far as creating the maConn, just clean up the session
-          if (maConn == null) {
-            cleanUpWTSession()
-          }
-        })
-
       // if the dial is aborted before we are ready, close the WebTransport session
       abortListener = () => {
-        if (abortListener != null) {
-          options.signal?.removeEventListener('abort', abortListener)
+        if (ready) {
+          cleanUpWTSession('noise_timeout')
+        } else {
+          cleanUpWTSession('ready_timeout')
         }
-
-        cleanUpWTSession()
       }
-      options.signal?.addEventListener('abort', abortListener)
+      options.signal?.addEventListener('abort', abortListener, {
+        once: true
+      })
 
-      await wt.ready
+      await Promise.race([
+        wt.closed,
+        wt.ready
+      ])
+
+      ready = true
+      this.metrics?.dialerEvents.increment({ ready: true })
+
+      // this promise resolves/throws when the session is closed
+      wt.closed.catch((err: Error) => {
+        log.error('error on remote wt session close', err)
+      })
+        .finally(() => {
+          cleanUpWTSession('remote_close')
+        })
 
       if (!await this.authenticateWebTransport(wt, localPeer, remotePeer, certhashes)) {
         throw new Error('Failed to authenticate webtransport')
       }
 
+      this.metrics?.dialerEvents.increment({ open: true })
+
       maConn = {
-        close: async (options?: AbortOptions) => {
+        close: async () => {
           log('Closing webtransport')
-          cleanUpWTSession()
+          cleanUpWTSession('close')
         },
         abort: (err: Error) => {
           log('aborting webtransport due to passed err', err)
-          cleanUpWTSession({
-            closeCode: 0,
-            reason: err.message
-          })
+          cleanUpWTSession('abort')
         },
         remoteAddr: ma,
         timeline: {
@@ -153,16 +169,19 @@ class WebTransportTransport implements Transport {
         ...inertDuplex()
       }
 
-      options?.signal?.throwIfAborted()
+      authenticated = true
 
-      return await options.upgrader.upgradeOutbound(maConn, { skipEncryption: true, muxerFactory: this.webtransportMuxer(wt, cleanUpWTSession), skipProtection: true })
+      return await options.upgrader.upgradeOutbound(maConn, { skipEncryption: true, muxerFactory: this.webtransportMuxer(wt), skipProtection: true })
     } catch (err: any) {
       log.error('caught wt session err', err)
 
-      cleanUpWTSession({
-        closeCode: 0,
-        reason: err.message
-      })
+      if (authenticated) {
+        cleanUpWTSession('upgrade_error')
+      } else if (ready) {
+        cleanUpWTSession('noise_error')
+      } else {
+        cleanUpWTSession('ready_error')
+      }
 
       throw err
     } finally {
@@ -220,7 +239,7 @@ class WebTransportTransport implements Transport {
     return true
   }
 
-  webtransportMuxer (wt: WebTransport, cleanUpWTSession: WebTransportSessionCleanup): StreamMuxerFactory {
+  webtransportMuxer (wt: WebTransport): StreamMuxerFactory {
     let streamIDCounter = 0
     const config = this.config
     return {
@@ -281,14 +300,17 @@ class WebTransportTransport implements Transport {
            */
           close: async (options?: AbortOptions) => {
             log('Closing webtransport muxer')
-            cleanUpWTSession()
+
+            await Promise.all(
+              activeStreams.map(async s => s.close(options))
+            )
           },
           abort: (err: Error) => {
             log('Aborting webtransport muxer with err:', err)
-            cleanUpWTSession({
-              closeCode: 0,
-              reason: err.message
-            })
+
+            for (const stream of activeStreams) {
+              stream.abort(err)
+            }
           },
           // This stream muxer is webtransport native. Therefore it doesn't plug in with any other duplex.
           ...inertDuplex()

package/src/utils/parse-multiaddr.ts

@@ -1,5 +1,7 @@
+import { CodeError } from '@libp2p/interface/errors'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { type Multiaddr, protocols } from '@multiformats/multiaddr'
+import { WebTransport } from '@multiformats/multiaddr-matcher'
 import { bases, digest } from 'multiformats/basics'
 import type { PeerId } from '@libp2p/interface/peer-id'
 import type { MultihashDigest } from 'multiformats/hashes/interface'
@@ -11,73 +13,46 @@ function decodeCerthashStr (s: string): MultihashDigest {
   return digest.decode(multibaseDecoder.decode(s))
 }
 
-export function parseMultiaddr (ma: Multiaddr): { url: string, certhashes: MultihashDigest[], remotePeer?: PeerId } {
+export interface ParsedMultiaddr {
+  url: string
+  certhashes: MultihashDigest[]
+  remotePeer?: PeerId
+}
+
+export function parseMultiaddr (ma: Multiaddr): ParsedMultiaddr {
+  if (!WebTransport.matches(ma)) {
+    throw new CodeError('Invalid multiaddr, was not a WebTransport address', 'ERR_INVALID_MULTIADDR')
+  }
+
   const parts = ma.stringTuples()
+  const certhashes = parts
+    .filter(([name, _]) => name === protocols('certhash').code)
+    .map(([_, value]) => decodeCerthashStr(value ?? ''))
+
+  // only take the first peer id in the multiaddr as it may be a relay
+  const remotePeer = parts
+    .filter(([name, _]) => name === protocols('p2p').code)
+    .map(([_, value]) => peerIdFromString(value ?? ''))[0]
+
+  const opts = ma.toOptions()
+  let host = opts.host
 
-  // This is simpler to have inline than extract into a separate function
-  // eslint-disable-next-line complexity
-  const { url, certhashes, remotePeer } = parts.reduce((state: { url: string, certhashes: MultihashDigest[], seenHost: boolean, seenPort: boolean, remotePeer?: PeerId }, [proto, value]) => {
-    switch (proto) {
-      case protocols('ip6').code:
-      // @ts-expect-error - ts error on switch fallthrough
-      case protocols('dns6').code:
-        if (value?.includes(':') === true) {
-          /**
-           * This resolves cases where `new globalThis.WebTransport` fails to construct because of an invalid URL being passed.
-           *
-           * `new URL('https://::1:4001/blah')` will throw a `TypeError: Failed to construct 'URL': Invalid URL`
-           * `new URL('https://[::1]:4001/blah')` is valid and will not.
-           *
-           * @see https://datatracker.ietf.org/doc/html/rfc3986#section-3.2.2
-           */
-          value = `[${value}]`
-        }
-      // eslint-disable-next-line no-fallthrough
-      case protocols('ip4').code:
-      case protocols('dns4').code:
-        if (state.seenHost || state.seenPort) {
-          throw new Error('Invalid multiaddr, saw host and already saw the host or port')
-        }
-        return {
-          ...state,
-          url: `${state.url}${value ?? ''}`,
-          seenHost: true
-        }
-      case protocols('quic').code:
-      case protocols('quic-v1').code:
-      case protocols('webtransport').code:
-        if (!state.seenHost || !state.seenPort) {
-          throw new Error("Invalid multiaddr, Didn't see host and port, but saw quic/webtransport")
-        }
-        return state
-      case protocols('udp').code:
-        if (state.seenPort) {
-          throw new Error('Invalid multiaddr, saw port but already saw the port')
-        }
-        return {
-          ...state,
-          url: `${state.url}:${value ?? ''}`,
-          seenPort: true
-        }
-      case protocols('certhash').code:
-        if (!state.seenHost || !state.seenPort) {
-          throw new Error('Invalid multiaddr, saw the certhash before seeing the host and port')
-        }
-        return {
-          ...state,
-          certhashes: state.certhashes.concat([decodeCerthashStr(value ?? '')])
-        }
-      case protocols('p2p').code:
-        return {
-          ...state,
-          remotePeer: peerIdFromString(value ?? '')
-        }
-      default:
-        throw new Error(`unexpected component in multiaddr: ${proto} ${protocols(proto).name} ${value ?? ''} `)
-    }
-  },
-  // All webtransport urls are https
-  { url: 'https://', seenHost: false, seenPort: false, certhashes: [] })
+  if (opts.family === 6 && host?.includes(':')) {
+    /**
+     * This resolves cases where `new WebTransport()` fails to construct because of an invalid URL being passed.
+     *
+     * `new URL('https://::1:4001/blah')` will throw a `TypeError: Failed to construct 'URL': Invalid URL`
+     * `new URL('https://[::1]:4001/blah')` is valid and will not.
+     *
+     * @see https://datatracker.ietf.org/doc/html/rfc3986#section-3.2.2
+     */
+    host = `[${host}]`
+  }
 
-  return { url, certhashes, remotePeer }
+  return {
+    // All webtransport urls are https
+    url: `https://${host}:${opts.port}`,
+    certhashes,
+    remotePeer
+  }
 }

package/dist/typedoc-urls.json

@@ -1,8 +0,0 @@
-{
-  "WebTransportComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webtransport.WebTransportComponents.html",
-  ".:WebTransportComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webtransport.WebTransportComponents.html",
-  "WebTransportInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webtransport.WebTransportInit.html",
-  ".:WebTransportInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webtransport.WebTransportInit.html",
-  "webTransport": "https://libp2p.github.io/js-libp2p/functions/_libp2p_webtransport.webTransport.html",
-  ".:webTransport": "https://libp2p.github.io/js-libp2p/functions/_libp2p_webtransport.webTransport.html"
-}