libp2p 2.7.2 → 2.7.3

package/src/upgrader.ts

@@ -1,12 +1,13 @@
 import { InvalidMultiaddrError, TooManyInboundProtocolStreamsError, TooManyOutboundProtocolStreamsError, LimitedConnectionError, setMaxListeners, InvalidPeerIdError } from '@libp2p/interface'
 import * as mss from '@libp2p/multistream-select'
 import { peerIdFromString } from '@libp2p/peer-id'
+import { anySignal } from 'any-signal'
 import { CustomProgressEvent } from 'progress-events'
 import { createConnection } from './connection/index.js'
-import { PROTOCOL_NEGOTIATION_TIMEOUT, UPGRADE_TIMEOUT } from './connection-manager/constants.js'
+import { PROTOCOL_NEGOTIATION_TIMEOUT, INBOUND_UPGRADE_TIMEOUT } from './connection-manager/constants.js'
 import { ConnectionDeniedError, ConnectionInterceptedError, EncryptionFailedError, MuxerUnavailableError } from './errors.js'
 import { DEFAULT_MAX_INBOUND_STREAMS, DEFAULT_MAX_OUTBOUND_STREAMS } from './registrar.js'
-import type { Libp2pEvents, AbortOptions, ComponentLogger, MultiaddrConnection, Connection, Stream, ConnectionProtector, NewStreamOptions, ConnectionEncrypter, SecuredConnection, ConnectionGater, TypedEventTarget, Metrics, PeerId, PeerStore, StreamMuxer, StreamMuxerFactory, Upgrader, UpgraderOptions, ConnectionLimits, SecureConnectionOptions, CounterGroup } from '@libp2p/interface'
+import type { Libp2pEvents, AbortOptions, ComponentLogger, MultiaddrConnection, Connection, Stream, ConnectionProtector, NewStreamOptions, ConnectionEncrypter, SecuredConnection, ConnectionGater, TypedEventTarget, Metrics, PeerId, PeerStore, StreamMuxer, StreamMuxerFactory, Upgrader as UpgraderInterface, UpgraderOptions, ConnectionLimits, SecureConnectionOptions, CounterGroup, ClearableSignal } from '@libp2p/interface'
 import type { ConnectionManager, Registrar } from '@libp2p/interface-internal'
 
 interface CreateConnectionOptions {
@@ -40,13 +41,6 @@ export interface UpgraderInit {
    */
   inboundUpgradeTimeout?: number
 
-  /**
-   * An amount of ms by which an outbound connection upgrade must complete
-   *
-   * @default 3000
-   */
-  outboundUpgradeTimeout?: number
-
   /**
    * When a new incoming stream is opened on a multiplexed connection, protocol
    * negotiation on that stream must complete within this many ms
@@ -120,12 +114,11 @@ export interface DefaultUpgraderComponents {
 
 type ConnectionDeniedType = keyof Pick<ConnectionGater, 'denyOutboundConnection' | 'denyInboundEncryptedConnection' | 'denyOutboundEncryptedConnection' | 'denyInboundUpgradedConnection' | 'denyOutboundUpgradedConnection'>
 
-export class DefaultUpgrader implements Upgrader {
+export class Upgrader implements UpgraderInterface {
   private readonly components: DefaultUpgraderComponents
   private readonly connectionEncrypters: Map<string, ConnectionEncrypter>
   private readonly streamMuxers: Map<string, StreamMuxerFactory>
   private readonly inboundUpgradeTimeout: number
-  private readonly outboundUpgradeTimeout: number
   private readonly inboundStreamProtocolNegotiationTimeout: number
   private readonly outboundStreamProtocolNegotiationTimeout: number
   private readonly events: TypedEventTarget<Libp2pEvents>
@@ -148,8 +141,7 @@ export class DefaultUpgrader implements Upgrader {
       this.streamMuxers.set(muxer.protocol, muxer)
     })
 
-    this.inboundUpgradeTimeout = init.inboundUpgradeTimeout ?? UPGRADE_TIMEOUT
-    this.outboundUpgradeTimeout = init.outboundUpgradeTimeout ?? UPGRADE_TIMEOUT
+    this.inboundUpgradeTimeout = init.inboundUpgradeTimeout ?? INBOUND_UPGRADE_TIMEOUT
     this.inboundStreamProtocolNegotiationTimeout = init.inboundStreamProtocolNegotiationTimeout ?? PROTOCOL_NEGOTIATION_TIMEOUT
     this.outboundStreamProtocolNegotiationTimeout = init.outboundStreamProtocolNegotiationTimeout ?? PROTOCOL_NEGOTIATION_TIMEOUT
     this.events = components.events
@@ -177,12 +169,25 @@ export class DefaultUpgrader implements Upgrader {
     }
   }
 
+  createInboundAbortSignal (signal: AbortSignal): ClearableSignal {
+    const output = anySignal([
+      AbortSignal.timeout(this.inboundUpgradeTimeout),
+      signal
+    ])
+    setMaxListeners(Infinity, output)
+
+    return output
+  }
+
   /**
    * Upgrades an inbound connection
    */
-  async upgradeInbound (maConn: MultiaddrConnection, opts: UpgraderOptions = {}): Promise<void> {
+  async upgradeInbound (maConn: MultiaddrConnection, opts: UpgraderOptions): Promise<void> {
     let accepted = false
 
+    // always apply upgrade timeout for incoming upgrades
+    const signal = this.createInboundAbortSignal(opts.signal)
+
     try {
       this.metrics.dials?.increment({
         inbound: true
@@ -196,7 +201,10 @@ export class DefaultUpgrader implements Upgrader {
 
       await this.shouldBlockConnection('denyInboundConnection', maConn)
 
-      await this._performUpgrade(maConn, 'inbound', opts)
+      await this._performUpgrade(maConn, 'inbound', {
+        ...opts,
+        signal
+      })
     } catch (err) {
       this.metrics.errors?.increment({
         inbound: true
@@ -204,6 +212,8 @@ export class DefaultUpgrader implements Upgrader {
 
       throw err
     } finally {
+      signal.clear()
+
       if (accepted) {
         this.components.connectionManager.afterUpgradeInbound()
       }
@@ -213,7 +223,7 @@ export class DefaultUpgrader implements Upgrader {
   /**
    * Upgrades an outbound connection
    */
-  async upgradeOutbound (maConn: MultiaddrConnection, opts: UpgraderOptions = {}): Promise<Connection> {
+  async upgradeOutbound (maConn: MultiaddrConnection, opts: UpgraderOptions): Promise<Connection> {
     try {
       this.metrics.dials?.increment({
         outbound: true
@@ -251,14 +261,6 @@ export class DefaultUpgrader implements Upgrader {
     let muxerFactory: StreamMuxerFactory | undefined
     let cryptoProtocol
 
-    if (opts.signal == null) {
-      maConn.log('no abort signal was passed while trying to upgrade connection, falling back to default timeout')
-
-      const upgradeTimeoutSignal = AbortSignal.timeout(direction === 'inbound' ? this.inboundUpgradeTimeout : this.outboundUpgradeTimeout)
-      setMaxListeners(Infinity, upgradeTimeoutSignal)
-      opts.signal = upgradeTimeoutSignal
-    }
-
     this.components.metrics?.trackMultiaddrConnection(maConn)
 
     maConn.log.trace('starting the %s connection upgrade', direction)
@@ -413,7 +415,7 @@ export class DefaultUpgrader implements Upgrader {
               }
 
               // after the handshake the returned stream can have early data so override
-              // the souce/sink
+              // the source/sink
               muxedStream.source = stream.source
               muxedStream.sink = stream.sink
               muxedStream.protocol = protocol
@@ -434,7 +436,7 @@ export class DefaultUpgrader implements Upgrader {
               }
 
               // If a protocol stream has been successfully negotiated and is to be passed to the application,
-              // the peerstore should ensure that the peer is registered with that protocol
+              // the peer store should ensure that the peer is registered with that protocol
               await this.components.peerStore.merge(remotePeer, {
                 protocols: [protocol]
               })
@@ -499,13 +501,13 @@ export class DefaultUpgrader implements Upgrader {
           }
 
           // If a protocol stream has been successfully negotiated and is to be passed to the application,
-          // the peerstore should ensure that the peer is registered with that protocol
+          // the peer store should ensure that the peer is registered with that protocol
           await this.components.peerStore.merge(remotePeer, {
             protocols: [protocol]
           })
 
           // after the handshake the returned stream can have early data so override
-          // the souce/sink
+          // the source/sink
           muxedStream.source = stream.source
           muxedStream.sink = stream.sink
           muxedStream.protocol = protocol

package/src/version.ts

@@ -1,2 +1,2 @@
-export const version = '2.7.2'
+export const version = '2.7.3'
 export const name = 'js-libp2p'