libp2p 2.1.1 → 2.1.2-0c5957836

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

@@ -1,5 +1,5 @@
 /* eslint-disable max-depth */
-import { TimeoutError, DialError, setMaxListeners } from '@libp2p/interface'
+import { TimeoutError, DialError, setMaxListeners, AbortError } from '@libp2p/interface'
 import { PeerMap } from '@libp2p/peer-collections'
 import { defaultAddressSort } from '@libp2p/utils/address-sort'
 import { PriorityQueue, type PriorityQueueJobOptions } from '@libp2p/utils/priority-queue'
@@ -103,7 +103,9 @@ export class DialQueue {
     })
     // a started job errored
     this.queue.addEventListener('error', (event) => {
-      this.log.error('error in dial queue', event.detail)
+      if (event.detail.name !== AbortError.name) {
+        this.log.error('error in dial queue - %e', event.detail)
+      }
     })
   }
 

package/src/connection-manager/index.ts

@@ -1,4 +1,4 @@
-import { InvalidParametersError, NotStartedError, start, stop } from '@libp2p/interface'
+import { InvalidMultiaddrError, InvalidParametersError, InvalidPeerIdError, NotStartedError, start, stop } from '@libp2p/interface'
 import { PeerMap } from '@libp2p/peer-collections'
 import { defaultAddressSort } from '@libp2p/utils/address-sort'
 import { RateLimiter } from '@libp2p/utils/rate-limiter'
@@ -57,17 +57,34 @@ export interface ConnectionManagerInit {
   /**
    * How long a dial attempt is allowed to take, including DNS resolution
    * of the multiaddr, opening a socket and upgrading it to a Connection.
+   *
+   * @default 5000
    */
   dialTimeout?: number
 
   /**
-   * When a new inbound connection is opened, the upgrade process (e.g. protect,
-   * encrypt, multiplex etc) must complete within this number of ms.
+   * When a new incoming connection is opened, the upgrade process (e.g.
+   * protect, encrypt, multiplex etc) must complete within this number of ms.
    *
-   * @default 30000
+   * @default 3000
    */
   inboundUpgradeTimeout?: number
 
+  /**
+   * When a new outbound connection is opened, the upgrade process (e.g.
+   * protect, encrypt, multiplex etc) must complete within this number of ms.
+   *
+   * @default 3000
+   */
+  outboundUpgradeTimeout?: number
+
+  /**
+   * Protocol negotiation must complete within this number of ms
+   *
+   * @default 2000
+   */
+  protocolNegotiationTimeout?: number
+
   /**
    * Multiaddr resolvers to use when dialling
    */
@@ -164,7 +181,6 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
   private readonly deny: Multiaddr[]
   private readonly maxIncomingPendingConnections: number
   private incomingPendingConnections: number
-  private outboundPendingConnections: number
   private readonly maxConnections: number
 
   public readonly dialQueue: DialQueue
@@ -175,6 +191,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
   private readonly metrics?: Metrics
   private readonly events: TypedEventTarget<Libp2pEvents>
   private readonly log: Logger
+  private readonly peerId: PeerId
 
   constructor (components: DefaultConnectionManagerComponents, init: ConnectionManagerInit = {}) {
     this.maxConnections = init.maxConnections ?? defaultOptions.maxConnections
@@ -189,6 +206,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
     this.connections = new PeerMap()
 
     this.started = false
+    this.peerId = components.peerId
     this.peerStore = components.peerStore
     this.metrics = components.metrics
     this.events = components.events
@@ -203,7 +221,6 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
     this.allow = (init.allow ?? []).map(ma => multiaddr(ma))
     this.deny = (init.deny ?? []).map(ma => multiaddr(ma))
 
-    this.outboundPendingConnections = 0
     this.incomingPendingConnections = 0
     this.maxIncomingPendingConnections = init.maxIncomingPendingConnections ?? defaultOptions.maxIncomingPendingConnections
 
@@ -266,8 +283,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
         const metric = {
           inbound: 0,
           'inbound pending': this.incomingPendingConnections,
-          outbound: 0,
-          'outbound pending': this.outboundPendingConnections
+          outbound: 0
         }
 
         for (const conns of this.connections.values()) {
@@ -468,54 +484,67 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
 
     options.signal?.throwIfAborted()
 
-    try {
-      this.outboundPendingConnections++
+    const { peerId } = getPeerAddress(peerIdOrMultiaddr)
 
-      const { peerId } = getPeerAddress(peerIdOrMultiaddr)
+    if (this.peerId.equals(peerId)) {
+      throw new InvalidPeerIdError('Can not dial self')
+    }
 
-      if (peerId != null && options.force !== true) {
-        this.log('dial %p', peerId)
-        const existingConnection = this.getConnections(peerId)
-          .find(conn => conn.limits == null)
+    if (peerId != null && options.force !== true) {
+      this.log('dial %p', peerId)
+      const existingConnection = this.getConnections(peerId)
+        .find(conn => conn.limits == null)
 
-        if (existingConnection != null) {
-          this.log('had an existing non-limited connection to %p', peerId)
+      if (existingConnection != null) {
+        this.log('had an existing non-limited connection to %p', peerId)
 
-          options.onProgress?.(new CustomProgressEvent('dial-queue:already-connected'))
-          return existingConnection
-        }
+        options.onProgress?.(new CustomProgressEvent('dial-queue:already-connected'))
+        return existingConnection
       }
+    }
 
-      const connection = await this.dialQueue.dial(peerIdOrMultiaddr, {
-        ...options,
-        priority: options.priority ?? DEFAULT_DIAL_PRIORITY
-      })
-      let peerConnections = this.connections.get(connection.remotePeer)
+    const connection = await this.dialQueue.dial(peerIdOrMultiaddr, {
+      ...options,
+      priority: options.priority ?? DEFAULT_DIAL_PRIORITY
+    })
 
-      if (peerConnections == null) {
-        peerConnections = []
-        this.connections.set(connection.remotePeer, peerConnections)
-      }
+    if (connection.remotePeer.equals(this.peerId)) {
+      const err = new InvalidPeerIdError('Can not dial self')
+      connection.abort(err)
+      throw err
+    }
 
-      // we get notified of connections via the Upgrader emitting "connection"
-      // events, double check we aren't already tracking this connection before
-      // storing it
-      let trackedConnection = false
+    let peerConnections = this.connections.get(connection.remotePeer)
 
-      for (const conn of peerConnections) {
-        if (conn.id === connection.id) {
-          trackedConnection = true
-        }
+    if (peerConnections == null) {
+      peerConnections = []
+      this.connections.set(connection.remotePeer, peerConnections)
+    }
+
+    // we get notified of connections via the Upgrader emitting "connection"
+    // events, double check we aren't already tracking this connection before
+    // storing it
+    let trackedConnection = false
+
+    for (const conn of peerConnections) {
+      if (conn.id === connection.id) {
+        trackedConnection = true
       }
 
-      if (!trackedConnection) {
-        peerConnections.push(connection)
+      // make sure we don't already have a connection to this multiaddr
+      if (options.force !== true && conn.id !== connection.id && conn.remoteAddr.equals(connection.remoteAddr)) {
+        connection.abort(new InvalidMultiaddrError('Duplicate multiaddr connection'))
+
+        // return the existing connection
+        return conn
       }
+    }
 
-      return connection
-    } finally {
-      this.outboundPendingConnections--
+    if (!trackedConnection) {
+      peerConnections.push(connection)
     }
+
+    return connection
   }
 
   async closeConnections (peerId: PeerId, options: AbortOptions = {}): Promise<void> {

package/src/libp2p.ts

@@ -110,7 +110,8 @@ export class Libp2p<T extends ServiceMap = ServiceMap> extends TypedEventEmitter
     this.components.upgrader = new DefaultUpgrader(this.components, {
       connectionEncrypters: (init.connectionEncrypters ?? []).map((fn, index) => this.configureComponent(`connection-encryption-${index}`, fn(this.components))),
       streamMuxers: (init.streamMuxers ?? []).map((fn, index) => this.configureComponent(`stream-muxers-${index}`, fn(this.components))),
-      inboundUpgradeTimeout: init.connectionManager?.inboundUpgradeTimeout
+      inboundUpgradeTimeout: init.connectionManager?.inboundUpgradeTimeout,
+      outboundUpgradeTimeout: init.connectionManager?.outboundUpgradeTimeout
     })
 
     // Setup the transport manager