libp2p 2.7.3-e2f49432b → 2.7.4-0555339ba

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,6 +59,20 @@ export class DialDeniedError extends Error {
   }
 }
 
+export class UnsupportedListenAddressError extends Error {
+  constructor (message = 'No transport was configured to listen on this address') {
+    super(message)
+    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 NoValidAddressesError extends Error {
   constructor (message = 'No valid addresses') {
     super(message)

package/src/transport-manager.ts

@@ -2,7 +2,7 @@ import { FaultTolerance, InvalidParametersError, NotStartedError } from '@libp2p
 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'
@@ -25,7 +25,7 @@ interface IPStats {
 }
 
 interface ListenStats {
-  unsupportedAddresses: Set<string>
+  errors: Map<string, Error>
   ipv4: IPStats
   ipv6: IPStats
 }
@@ -207,9 +207,7 @@ export class DefaultTransportManager implements TransportManager, Startable {
     // 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 = {
-      unsupportedAddresses: new Set(
-        addrs.map(ma => ma.toString())
-      ),
+      errors: new Map(),
       ipv4: {
         success: 0,
         attempts: 0
@@ -220,6 +218,10 @@ export class DefaultTransportManager implements TransportManager, Startable {
       }
     }
 
+    addrs.forEach(ma => {
+      listenStats.errors.set(ma.toString(), new UnsupportedListenAddressError())
+    })
+
     const tasks: Array<Promise<void>> = []
 
     for (const [key, transport] of this.transports.entries()) {
@@ -269,7 +271,7 @@ export class DefaultTransportManager implements TransportManager, Startable {
         tasks.push(
           listener.listen(addr)
             .then(() => {
-              listenStats.unsupportedAddresses.delete(addr.toString())
+              listenStats.errors.delete(addr.toString())
 
               if (IP4.matches(addr)) {
                 listenStats.ipv4.success++
@@ -280,6 +282,7 @@ export class DefaultTransportManager implements TransportManager, Startable {
               }
             }, (err) => {
               this.log.error('transport %s could not listen on address %a - %e', key, addr, err)
+              listenStats.errors.set(addr.toString(), err)
               throw err
             })
         )
@@ -308,9 +311,13 @@ export class DefaultTransportManager implements TransportManager, Startable {
     }
 
     // if a configured address was not able to be listened on, throw an error
-    throw new NoValidAddressesError(`No configured transport could listen on these addresses, please remove them from your config: ${[
-      ...listenStats.unsupportedAddresses
-    ].join(', ')}`)
+    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 {

package/src/version.ts

@@ -1,2 +1,2 @@
-export const version = '2.7.3-e2f49432b'
+export const version = '2.7.4-0555339ba'
 export const name = 'js-libp2p'