libp2p 2.7.3 → 2.7.4-22e62d00f

package/src/connection-manager/dial-queue.ts

@@ -203,7 +203,7 @@ export class DialQueue {
 
     options.onProgress?.(new CustomProgressEvent('dial-queue:add-to-dial-queue'))
     return this.queue.add(async (options) => {
-      options?.onProgress?.(new CustomProgressEvent('dial-queue:start-dial'))
+      options.onProgress?.(new CustomProgressEvent('dial-queue:start-dial'))
       // create abort conditions - need to do this before `calculateMultiaddrs` as
       // we may be about to resolve a dns addr which can time out
       const signal = anySignal([
@@ -212,103 +212,145 @@ export class DialQueue {
       ])
       setMaxListeners(Infinity, signal)
 
-      let addrsToDial: Address[]
-
       try {
-        // load addresses from address book, resolve and dnsaddrs, filter
-        // undialables, add peer IDs, etc
-        addrsToDial = await this.calculateMultiaddrs(peerId, options?.multiaddrs, {
-          ...options,
-          signal
-        })
+        return await this.dialPeer(options, signal)
+      } finally {
+        // clean up abort signals/controllers
+        signal.clear()
+      }
+    }, {
+      peerId,
+      priority: options.priority ?? DEFAULT_DIAL_PRIORITY,
+      multiaddrs: new Set(multiaddrs.map(ma => ma.toString())),
+      signal: options.signal ?? AbortSignal.timeout(this.dialTimeout),
+      onProgress: options.onProgress
+    })
+  }
 
-        options?.onProgress?.(new CustomProgressEvent<Address[]>('dial-queue:calculated-addresses', addrsToDial))
+  private async dialPeer (options: DialQueueJobOptions, signal: AbortSignal): Promise<Connection> {
+    const peerId = options.peerId
+    const multiaddrs = options.multiaddrs
+    const failedMultiaddrs = new Set<string>()
 
-        addrsToDial.map(({ multiaddr }) => multiaddr.toString()).forEach(addr => {
-          options?.multiaddrs.add(addr)
-        })
-      } catch (err) {
-        signal.clear()
-        throw err
+    // if we have no multiaddrs, only a peer id, set a flag so we will look the
+    // peer up in the peer routing to obtain multiaddrs
+    let forcePeerLookup = options.multiaddrs.size === 0
+
+    let dialed = 0
+    let dialIteration = 0
+    const errors: Error[] = []
+
+    this.log('starting dial to %p', peerId)
+
+    // repeat this operation in case addresses are added to the dial while we
+    // resolve multiaddrs, etc
+    while (forcePeerLookup || multiaddrs.size > 0) {
+      dialIteration++
+
+      // only perform peer lookup once
+      forcePeerLookup = false
+
+      // the addresses we will dial
+      const addrsToDial: Address[] = []
+
+      // copy the addresses into a new set
+      const addrs = new Set(options.multiaddrs)
+
+      // empty the old set - subsequent dial attempts for the same peer id may
+      // add more addresses to try
+      multiaddrs.clear()
+
+      this.log('calculating addrs to dial %p from %s', peerId, [...addrs])
+
+      // load addresses from address book, resolve and dnsaddrs, filter
+      // undialables, add peer IDs, etc
+      const calculatedAddrs = await this.calculateMultiaddrs(peerId, addrs, {
+        ...options,
+        signal
+      })
+
+      for (const addr of calculatedAddrs) {
+        // skip any addresses we have previously failed to dial
+        if (failedMultiaddrs.has(addr.multiaddr.toString())) {
+          this.log.trace('skipping previously failed multiaddr %a while dialing %p', addr.multiaddr, peerId)
+          continue
+        }
+
+        addrsToDial.push(addr)
       }
 
-      try {
-        let dialed = 0
-        const errors: Error[] = []
+      this.log('%s dial to %p with %s', dialIteration === 1 ? 'starting' : 'continuing', peerId, addrsToDial.map(ma => ma.multiaddr.toString()))
 
-        for (const address of addrsToDial) {
-          if (dialed === this.maxPeerAddrsToDial) {
-            this.log('dialed maxPeerAddrsToDial (%d) addresses for %p, not trying any others', dialed, peerId)
+      options?.onProgress?.(new CustomProgressEvent<Address[]>('dial-queue:calculated-addresses', addrsToDial))
 
-            throw new DialError('Peer had more than maxPeerAddrsToDial')
-          }
+      for (const address of addrsToDial) {
+        if (dialed === this.maxPeerAddrsToDial) {
+          this.log('dialed maxPeerAddrsToDial (%d) addresses for %p, not trying any others', dialed, options.peerId)
 
-          dialed++
+          throw new DialError('Peer had more than maxPeerAddrsToDial')
+        }
 
+        dialed++
+
+        try {
+          // try to dial the address
+          const conn = await this.components.transportManager.dial(address.multiaddr, {
+            ...options,
+            signal
+          })
+
+          this.log('dial to %a succeeded', address.multiaddr)
+
+          // record the successful dial and the address
           try {
-            const conn = await this.components.transportManager.dial(address.multiaddr, {
-              ...options,
-              signal
+            await this.components.peerStore.merge(conn.remotePeer, {
+              multiaddrs: [
+                conn.remoteAddr
+              ],
+              metadata: {
+                [LAST_DIAL_SUCCESS_KEY]: uint8ArrayFromString(Date.now().toString())
+              }
             })
+          } catch (err: any) {
+            this.log.error('could not update last dial failure key for %p', peerId, err)
+          }
+
+          // dial successful, return the connection
+          return conn
+        } catch (err: any) {
+          this.log.error('dial failed to %a', address.multiaddr, err)
 
-            this.log('dial to %a succeeded', address.multiaddr)
+          // ensure we don't dial it again in this attempt
+          failedMultiaddrs.add(address.multiaddr.toString())
 
-            // record the successful dial and the address
+          if (peerId != null) {
+            // record the failed dial
             try {
-              await this.components.peerStore.merge(conn.remotePeer, {
-                multiaddrs: [
-                  conn.remoteAddr
-                ],
+              await this.components.peerStore.merge(peerId, {
                 metadata: {
-                  [LAST_DIAL_SUCCESS_KEY]: uint8ArrayFromString(Date.now().toString())
+                  [LAST_DIAL_FAILURE_KEY]: uint8ArrayFromString(Date.now().toString())
                 }
               })
             } catch (err: any) {
               this.log.error('could not update last dial failure key for %p', peerId, err)
             }
+          }
 
-            return conn
-          } catch (err: any) {
-            this.log.error('dial failed to %a', address.multiaddr, err)
-
-            if (peerId != null) {
-              // record the failed dial
-              try {
-                await this.components.peerStore.merge(peerId, {
-                  metadata: {
-                    [LAST_DIAL_FAILURE_KEY]: uint8ArrayFromString(Date.now().toString())
-                  }
-                })
-              } catch (err: any) {
-                this.log.error('could not update last dial failure key for %p', peerId, err)
-              }
-            }
-
-            // the user/dial timeout/shutdown controller signal aborted
-            if (signal.aborted) {
-              throw new TimeoutError(err.message)
-            }
-
-            errors.push(err)
+          // the user/dial timeout/shutdown controller signal aborted
+          if (signal.aborted) {
+            throw new TimeoutError(err.message)
           }
-        }
 
-        if (errors.length === 1) {
-          throw errors[0]
+          errors.push(err)
         }
-
-        throw new AggregateError(errors, 'All multiaddr dials failed')
-      } finally {
-        // clean up abort signals/controllers
-        signal.clear()
       }
-    }, {
-      peerId,
-      priority: options.priority ?? DEFAULT_DIAL_PRIORITY,
-      multiaddrs: new Set(multiaddrs.map(ma => ma.toString())),
-      signal: options.signal ?? AbortSignal.timeout(this.dialTimeout),
-      onProgress: options.onProgress
-    })
+    }
+
+    if (errors.length === 1) {
+      throw errors[0]
+    }
+
+    throw new AggregateError(errors, 'All multiaddr dials failed')
   }
 
   // eslint-disable-next-line complexity
@@ -358,8 +400,10 @@ export class DialQueue {
             isCertified: false
           })))
         } catch (err: any) {
-          if (err.name !== 'NoPeerRoutersError') {
-            this.log.error('looking up multiaddrs for %p in the peer routing failed', peerId, err)
+          if (err.name === 'NoPeerRoutersError') {
+            this.log('no peer routers configured', peerId)
+          } else {
+            this.log.error('looking up multiaddrs for %p in the peer routing failed - %e', peerId, err)
           }
         }
       }

package/src/errors.ts

@@ -59,17 +59,24 @@ export class DialDeniedError extends Error {
   }
 }
 
-export class NoValidAddressesError extends Error {
-  constructor (message = 'No valid addresses') {
+export class UnsupportedListenAddressError extends Error {
+  constructor (message = 'No transport was configured to listen on this address') {
     super(message)
-    this.name = 'NoValidAddressesError'
+    this.name = 'UnsupportedListenAddressError'
+  }
+}
+
+export class UnsupportedListenAddressesError extends Error {
+  constructor (message = 'Configured listen addresses could not be listened on') {
+    super(message)
+    this.name = 'UnsupportedListenAddressesError'
   }
 }
 
-export class NoSupportedAddressesError extends Error {
-  constructor (message = 'No supported addresses') {
+export class NoValidAddressesError extends Error {
+  constructor (message = 'No valid addresses') {
     super(message)
-    this.name = 'NoSupportedAddressesError'
+    this.name = 'NoValidAddressesError'
   }
 }
 

package/src/transport-manager.ts

@@ -1,7 +1,8 @@
 import { FaultTolerance, InvalidParametersError, NotStartedError } from '@libp2p/interface'
 import { trackedMap } from '@libp2p/utils/tracked-map'
+import { IP4, IP6 } from '@multiformats/multiaddr-matcher'
 import { CustomProgressEvent } from 'progress-events'
-import { NoValidAddressesError, TransportUnavailableError } from './errors.js'
+import { TransportUnavailableError, UnsupportedListenAddressError, UnsupportedListenAddressesError } from './errors.js'
 import type { Libp2pEvents, ComponentLogger, Logger, Connection, TypedEventTarget, Metrics, Startable, Listener, Transport, Upgrader } from '@libp2p/interface'
 import type { AddressManager, TransportManager, TransportManagerDialOptions } from '@libp2p/interface-internal'
 import type { Multiaddr } from '@multiformats/multiaddr'
@@ -18,6 +19,17 @@ export interface DefaultTransportManagerComponents {
   logger: ComponentLogger
 }
 
+interface IPStats {
+  success: number
+  attempts: number
+}
+
+interface ListenStats {
+  errors: Map<string, Error>
+  ipv4: IPStats
+  ipv6: IPStats
+}
+
 export class DefaultTransportManager implements TransportManager, Startable {
   private readonly log: Logger
   private readonly components: DefaultTransportManagerComponents
@@ -192,11 +204,28 @@ export class DefaultTransportManager implements TransportManager, Startable {
       return
     }
 
-    const couldNotListen = []
+    // track IPv4/IPv6 results - if we succeed on IPv4 but all IPv6 attempts
+    // fail then we are probably on a network without IPv6 support
+    const listenStats: ListenStats = {
+      errors: new Map(),
+      ipv4: {
+        success: 0,
+        attempts: 0
+      },
+      ipv6: {
+        success: 0,
+        attempts: 0
+      }
+    }
+
+    addrs.forEach(ma => {
+      listenStats.errors.set(ma.toString(), new UnsupportedListenAddressError())
+    })
+
+    const tasks: Array<Promise<void>> = []
 
     for (const [key, transport] of this.transports.entries()) {
       const supportedAddrs = transport.listenFilter(addrs)
-      const tasks = []
 
       // For each supported multiaddr, create a listener
       for (const addr of supportedAddrs) {
@@ -231,36 +260,75 @@ export class DefaultTransportManager implements TransportManager, Startable {
           })
         })
 
+        // track IPv4/IPv6 support
+        if (IP4.matches(addr)) {
+          listenStats.ipv4.attempts++
+        } else if (IP6.matches(addr)) {
+          listenStats.ipv6.attempts++
+        }
+
         // We need to attempt to listen on everything
-        tasks.push(listener.listen(addr))
+        tasks.push(
+          listener.listen(addr)
+            .then(() => {
+              listenStats.errors.delete(addr.toString())
+
+              if (IP4.matches(addr)) {
+                listenStats.ipv4.success++
+              }
+
+              if (IP6.matches(addr)) {
+                listenStats.ipv6.success++
+              }
+            }, (err) => {
+              this.log.error('transport %s could not listen on address %a - %e', key, addr, err)
+              listenStats.errors.set(addr.toString(), err)
+              throw err
+            })
+        )
       }
+    }
 
-      // Keep track of transports we had no addresses for
-      if (tasks.length === 0) {
-        couldNotListen.push(key)
-        continue
-      }
+    const results = await Promise.allSettled(tasks)
 
-      const results = await Promise.allSettled(tasks)
-      // If we are listening on at least 1 address, succeed.
-      // TODO: we should look at adding a retry (`p-retry`) here to better support
-      // listening on remote addresses as they may be offline. We could then potentially
-      // just wait for any (`p-any`) listener to succeed on each transport before returning
-      const isListening = results.find(r => r.status === 'fulfilled')
-      if ((isListening == null) && this.faultTolerance !== FaultTolerance.NO_FATAL) {
-        throw new NoValidAddressesError(`Transport (${key}) could not listen on any available address`)
-      }
+    // listening on all addresses, all good
+    if (results.length > 0 && results.every(res => res.status === 'fulfilled')) {
+      return
     }
 
-    // If no transports were able to listen, throw an error. This likely
-    // means we were given addresses we do not have transports for
-    if (couldNotListen.length === this.transports.size) {
-      const message = `no valid addresses were provided for transports [${couldNotListen.join(', ')}]`
-      if (this.faultTolerance === FaultTolerance.FATAL_ALL) {
-        throw new NoValidAddressesError(message)
-      }
-      this.log(`libp2p in dial mode only: ${message}`)
+    // detect lack of IPv6 support on the current network - if we tried to
+    // listen on IPv4 and IPv6 addresses, and all IPv4 addresses succeeded but
+    // all IPv6 addresses fail, then we can assume there's no IPv6 here
+    if (this.ipv6Unsupported(listenStats)) {
+      this.log('all IPv4 addresses succeed but all IPv6 failed')
+      return
+    }
+
+    if (this.faultTolerance === FaultTolerance.NO_FATAL) {
+      // ok to be dial-only
+      this.log('failed to listen on any address but fault tolerance allows this')
+      return
     }
+
+    // if a configured address was not able to be listened on, throw an error
+    throw new UnsupportedListenAddressesError(`Some configured addresses failed to be listened on, you may need to remove one or more listen addresses from your configuration or set \`transportManager.faultTolerance\` to NO_FATAL:\n${
+      [...listenStats.errors.entries()].map(([addr, err]) => {
+        return `
+  ${addr}: ${`${err.stack ?? err}`.split('\n').join('\n  ')}
+`
+      }).join('')
+    }`)
+  }
+
+  private ipv6Unsupported (listenStats: ListenStats): boolean {
+    if (listenStats.ipv4.attempts === 0 || listenStats.ipv6.attempts === 0) {
+      return false
+    }
+
+    const allIpv4Succeeded = listenStats.ipv4.attempts === listenStats.ipv4.success
+    const allIpv6Failed = listenStats.ipv6.success === 0
+
+    return allIpv4Succeeded && allIpv6Failed
   }
 
   /**

package/src/version.ts

@@ -1,2 +1,2 @@
-export const version = '2.7.3'
+export const version = '2.7.4-22e62d00f'
 export const name = 'js-libp2p'

package/dist/typedoc-urls.json

@@ -1,21 +0,0 @@
-{
-  "AddressFilter": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.AddressFilter.html",
-  "AddressManagerInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.AddressManagerInit.html",
-  "ConnectionManagerInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.ConnectionManagerInit.html",
-  "ConnectionMonitorInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.ConnectionMonitorInit.html",
-  "Libp2pInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.Libp2pInit.html",
-  ".:Libp2pInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.Libp2pInit.html",
-  "TransportManagerInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.TransportManagerInit.html",
-  "Libp2pOptions": "https://libp2p.github.io/js-libp2p/types/libp2p.index.Libp2pOptions.html",
-  ".:Libp2pOptions": "https://libp2p.github.io/js-libp2p/types/libp2p.index.Libp2pOptions.html",
-  "ServiceFactoryMap": "https://libp2p.github.io/js-libp2p/types/libp2p.index.ServiceFactoryMap.html",
-  ".:ServiceFactoryMap": "https://libp2p.github.io/js-libp2p/types/libp2p.index.ServiceFactoryMap.html",
-  "createLibp2p": "https://libp2p.github.io/js-libp2p/functions/libp2p.index.createLibp2p.html",
-  ".:createLibp2p": "https://libp2p.github.io/js-libp2p/functions/libp2p.index.createLibp2p.html",
-  "userAgent": "https://libp2p.github.io/js-libp2p/functions/libp2p.user_agent.userAgent.html",
-  "./user-agent:userAgent": "https://libp2p.github.io/js-libp2p/functions/libp2p.user_agent.userAgent.html",
-  "name": "https://libp2p.github.io/js-libp2p/variables/libp2p.version.name.html",
-  "./version:name": "https://libp2p.github.io/js-libp2p/variables/libp2p.version.name.html",
-  "version": "https://libp2p.github.io/js-libp2p/variables/libp2p.version.version.html",
-  "./version:version": "https://libp2p.github.io/js-libp2p/variables/libp2p.version.version.html"
-}