libp2p 1.5.1 → 1.5.2

package/src/connection-manager/connection-pruner.ts

@@ -1,6 +1,7 @@
 import { PeerMap } from '@libp2p/peer-collections'
+import { safelyCloseConnectionIfUnused } from '@libp2p/utils/close'
 import { MAX_CONNECTIONS } from './constants.js'
-import type { Libp2pEvents, Logger, ComponentLogger, TypedEventTarget, PeerStore } from '@libp2p/interface'
+import type { Libp2pEvents, Logger, ComponentLogger, TypedEventTarget, PeerStore, Connection } from '@libp2p/interface'
 import type { ConnectionManager } from '@libp2p/interface-internal'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
@@ -56,14 +57,13 @@ export class ConnectionPruner {
   async maybePruneConnections (): Promise<void> {
     const connections = this.connectionManager.getConnections()
     const numConnections = connections.length
-    const toPrune = Math.max(numConnections - this.maxConnections, 0)
 
     this.log('checking max connections limit %d/%d', numConnections, this.maxConnections)
+
     if (numConnections <= this.maxConnections) {
       return
     }
 
-    this.log('max connections limit exceeded %d/%d, pruning %d connection(s)', numConnections, this.maxConnections, toPrune)
     const peerValues = new PeerMap<number>()
 
     // work out peer values
@@ -90,35 +90,10 @@ export class ConnectionPruner {
       }
     }
 
-    // sort by value, lowest to highest
-    const sortedConnections = connections.sort((a, b) => {
-      const peerAValue = peerValues.get(a.remotePeer) ?? 0
-      const peerBValue = peerValues.get(b.remotePeer) ?? 0
-
-      if (peerAValue > peerBValue) {
-        return 1
-      }
-
-      if (peerAValue < peerBValue) {
-        return -1
-      }
-
-      // if the peers have an equal tag value then we want to close short-lived connections first
-      const connectionALifespan = a.timeline.open
-      const connectionBLifespan = b.timeline.open
-
-      if (connectionALifespan < connectionBLifespan) {
-        return 1
-      }
-
-      if (connectionALifespan > connectionBLifespan) {
-        return -1
-      }
-
-      return 0
-    })
+    const sortedConnections = this.sortConnections(connections, peerValues)
 
     // close some connections
+    const toPrune = Math.max(numConnections - this.maxConnections, 0)
     const toClose = []
 
     for (const connection of sortedConnections) {
@@ -141,15 +116,71 @@ export class ConnectionPruner {
     // close connections
     await Promise.all(
       toClose.map(async connection => {
-        try {
-          await connection.close()
-        } catch (err) {
-          this.log.error(err)
-        }
+        await safelyCloseConnectionIfUnused(connection, {
+          signal: AbortSignal.timeout(1000)
+        })
       })
     )
 
     // despatch prune event
     this.events.safeDispatchEvent('connection:prune', { detail: toClose })
   }
+
+  sortConnections (connections: Connection[], peerValues: PeerMap<number>): Connection[] {
+    return connections
+      // sort by connection age, newest to oldest
+      .sort((a, b) => {
+        const connectionALifespan = a.timeline.open
+        const connectionBLifespan = b.timeline.open
+
+        if (connectionALifespan < connectionBLifespan) {
+          return 1
+        }
+
+        if (connectionALifespan > connectionBLifespan) {
+          return -1
+        }
+
+        return 0
+      })
+      // sort by direction, incoming first then outgoing
+      .sort((a, b) => {
+        if (a.direction === 'outbound' && b.direction === 'inbound') {
+          return 1
+        }
+
+        if (a.direction === 'inbound' && b.direction === 'outbound') {
+          return -1
+        }
+
+        return 0
+      })
+      // sort by number of streams, lowest to highest
+      .sort((a, b) => {
+        if (a.streams.length > b.streams.length) {
+          return 1
+        }
+
+        if (a.streams.length < b.streams.length) {
+          return -1
+        }
+
+        return 0
+      })
+      // sort by tag value, lowest to highest
+      .sort((a, b) => {
+        const peerAValue = peerValues.get(a.remotePeer) ?? 0
+        const peerBValue = peerValues.get(b.remotePeer) ?? 0
+
+        if (peerAValue > peerBValue) {
+          return 1
+        }
+
+        if (peerAValue < peerBValue) {
+          return -1
+        }
+
+        return 0
+      })
+  }
 }

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

@@ -2,7 +2,7 @@
 import { CodeError, AggregateCodeError, ERR_TIMEOUT, setMaxListeners } from '@libp2p/interface'
 import { PeerMap } from '@libp2p/peer-collections'
 import { defaultAddressSort } from '@libp2p/utils/address-sort'
-import { Queue, type QueueAddOptions } from '@libp2p/utils/queue'
+import { PriorityQueue, type PriorityQueueJobOptions } from '@libp2p/utils/priority-queue'
 import { type Multiaddr, type Resolver, resolvers, multiaddr } from '@multiformats/multiaddr'
 import { dnsaddrResolver } from '@multiformats/multiaddr/resolvers'
 import { Circuit } from '@multiformats/multiaddr-matcher'
@@ -18,6 +18,7 @@ import {
   MAX_DIAL_QUEUE_LENGTH
 } from './constants.js'
 import { resolveMultiaddrs } from './utils.js'
+import { DEFAULT_DIAL_PRIORITY } from './index.js'
 import type { AddressSorter, AbortOptions, ComponentLogger, Logger, Connection, ConnectionGater, Metrics, PeerId, Address, PeerStore, PeerRouting, IsDialableOptions } from '@libp2p/interface'
 import type { TransportManager } from '@libp2p/interface-internal'
 import type { DNS } from '@multiformats/dns'
@@ -32,7 +33,7 @@ export interface DialOptions extends AbortOptions {
   force?: boolean
 }
 
-interface DialQueueJobOptions extends QueueAddOptions {
+interface DialQueueJobOptions extends PriorityQueueJobOptions {
   peerId?: PeerId
   multiaddrs: Set<string>
 }
@@ -70,7 +71,7 @@ interface DialQueueComponents {
 }
 
 export class DialQueue {
-  public queue: Queue<Connection, DialQueueJobOptions>
+  public queue: PriorityQueue<Connection, DialQueueJobOptions>
   private readonly components: DialQueueComponents
   private readonly addressSorter: AddressSorter
   private readonly maxPeerAddrsToDial: number
@@ -97,7 +98,7 @@ export class DialQueue {
     }
 
     // controls dial concurrency
-    this.queue = new Queue({
+    this.queue = new PriorityQueue({
       concurrency: init.maxParallelDials ?? defaultOptions.maxParallelDials,
       metricName: 'libp2p_dial_queue',
       metrics: components.metrics
@@ -277,7 +278,7 @@ export class DialQueue {
       }
     }, {
       peerId,
-      priority: options.priority,
+      priority: options.priority ?? DEFAULT_DIAL_PRIORITY,
       multiaddrs: new Set(multiaddrs.map(ma => ma.toString())),
       signal: options.signal
     })

package/src/connection-manager/index.ts

@@ -8,13 +8,13 @@ import { codes } from '../errors.js'
 import { getPeerAddress } from '../get-peer.js'
 import { AutoDial } from './auto-dial.js'
 import { ConnectionPruner } from './connection-pruner.js'
-import { AUTO_DIAL_CONCURRENCY, AUTO_DIAL_MAX_QUEUE_LENGTH, AUTO_DIAL_PRIORITY, DIAL_TIMEOUT, INBOUND_CONNECTION_THRESHOLD, MAX_CONNECTIONS, MAX_DIAL_QUEUE_LENGTH, MAX_INCOMING_PENDING_CONNECTIONS, MAX_PARALLEL_DIALS, MAX_PEER_ADDRS_TO_DIAL, MIN_CONNECTIONS } from './constants.js'
+import { AUTO_DIAL_CONCURRENCY, AUTO_DIAL_DISCOVERED_PEERS_DEBOUNCE, AUTO_DIAL_MAX_QUEUE_LENGTH, AUTO_DIAL_PEER_RETRY_THRESHOLD, AUTO_DIAL_PRIORITY, DIAL_TIMEOUT, INBOUND_CONNECTION_THRESHOLD, MAX_CONNECTIONS, MAX_DIAL_QUEUE_LENGTH, MAX_INCOMING_PENDING_CONNECTIONS, MAX_PARALLEL_DIALS, MAX_PEER_ADDRS_TO_DIAL, MIN_CONNECTIONS } from './constants.js'
 import { DialQueue } from './dial-queue.js'
 import type { PendingDial, AddressSorter, Libp2pEvents, AbortOptions, ComponentLogger, Logger, Connection, MultiaddrConnection, ConnectionGater, TypedEventTarget, Metrics, PeerId, Peer, PeerStore, Startable, PendingDialStatus, PeerRouting, IsDialableOptions } from '@libp2p/interface'
 import type { ConnectionManager, OpenConnectionOptions, TransportManager } from '@libp2p/interface-internal'
 import type { JobStatus } from '@libp2p/utils/queue'
 
-const DEFAULT_DIAL_PRIORITY = 50
+export const DEFAULT_DIAL_PRIORITY = 50
 
 export interface ConnectionManagerInit {
   /**
@@ -147,7 +147,9 @@ const defaultOptions = {
   maxIncomingPendingConnections: MAX_INCOMING_PENDING_CONNECTIONS,
   autoDialConcurrency: AUTO_DIAL_CONCURRENCY,
   autoDialPriority: AUTO_DIAL_PRIORITY,
-  autoDialMaxQueueLength: AUTO_DIAL_MAX_QUEUE_LENGTH
+  autoDialMaxQueueLength: AUTO_DIAL_MAX_QUEUE_LENGTH,
+  autoDialPeerRetryThreshold: AUTO_DIAL_PEER_RETRY_THRESHOLD,
+  autoDialDiscoveredPeersDebounce: AUTO_DIAL_DISCOVERED_PEERS_DEBOUNCE
 }
 
 export interface DefaultConnectionManagerComponents {
@@ -229,6 +231,8 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
       minConnections,
       autoDialConcurrency: init.autoDialConcurrency ?? defaultOptions.autoDialConcurrency,
       autoDialPriority: init.autoDialPriority ?? defaultOptions.autoDialPriority,
+      autoDialPeerRetryThreshold: init.autoDialPeerRetryThreshold ?? defaultOptions.autoDialPeerRetryThreshold,
+      autoDialDiscoveredPeersDebounce: init.autoDialDiscoveredPeersDebounce ?? defaultOptions.autoDialDiscoveredPeersDebounce,
       maxQueueLength: init.autoDialMaxQueueLength ?? defaultOptions.autoDialMaxQueueLength
     })
 

package/src/version.ts

@@ -1,2 +1,2 @@
-export const version = '1.5.1'
+export const version = '1.5.2'
 export const name = 'libp2p'