libp2p 0.37.3-e6f646e → 0.38.0-0e7096d

package/src/connection-manager/dialer/index.ts

@@ -177,7 +177,7 @@ export class Dialer implements Startable, Initializable {
 
     log('creating dial target for %p', id)
 
-    const dialTarget = await this._createCancellableDialTarget(id)
+    const dialTarget = await this._createCancellableDialTarget(id, options)
 
     if (dialTarget.addrs.length === 0) {
       throw errCode(new Error('The dial request has no valid addresses'), codes.ERR_NO_VALID_ADDRESSES)
@@ -207,7 +207,7 @@ export class Dialer implements Startable, Initializable {
    * The dial to the first address that is successfully able to upgrade a connection
    * will be used.
    */
-  async _createCancellableDialTarget (peer: PeerId): Promise<DialTarget> {
+  async _createCancellableDialTarget (peer: PeerId, options: AbortOptions): Promise<DialTarget> {
     // Make dial target promise cancellable
     const id = `${(parseInt(String(Math.random() * 1e9), 10)).toString()}${Date.now()}`
     const cancellablePromise = new Promise<DialTarget>((resolve, reject) => {
@@ -216,7 +216,7 @@ export class Dialer implements Startable, Initializable {
 
     try {
       const dialTarget = await Promise.race([
-        this._createDialTarget(peer),
+        this._createDialTarget(peer, options),
         cancellablePromise
       ])
 
@@ -232,7 +232,7 @@ export class Dialer implements Startable, Initializable {
    * If a multiaddr is received it should be the first address attempted.
    * Multiaddrs not supported by the available transports will be filtered out.
    */
-  async _createDialTarget (peer: PeerId): Promise<DialTarget> {
+  async _createDialTarget (peer: PeerId, options: AbortOptions): Promise<DialTarget> {
     const knownAddrs = await pipe(
       await this.components.getPeerStore().addressBook.get(peer),
       (source) => filter(source, async (address) => {
@@ -253,7 +253,7 @@ export class Dialer implements Startable, Initializable {
 
     const addrs: Multiaddr[] = []
     for (const a of knownAddrs) {
-      const resolvedAddrs = await this._resolve(a)
+      const resolvedAddrs = await this._resolve(a, options)
       resolvedAddrs.forEach(ra => addrs.push(ra))
     }
 
@@ -341,7 +341,7 @@ export class Dialer implements Startable, Initializable {
   /**
    * Resolve multiaddr recursively
    */
-  async _resolve (ma: Multiaddr): Promise<Multiaddr[]> {
+  async _resolve (ma: Multiaddr, options: AbortOptions): Promise<Multiaddr[]> {
     // TODO: recursive logic should live in multiaddr once dns4/dns6 support is in place
     // Now only supporting resolve for dnsaddr
     const resolvableProto = ma.protoNames().includes('dnsaddr')
@@ -351,9 +351,9 @@ export class Dialer implements Startable, Initializable {
       return [ma]
     }
 
-    const resolvedMultiaddrs = await this._resolveRecord(ma)
+    const resolvedMultiaddrs = await this._resolveRecord(ma, options)
     const recursiveMultiaddrs = await Promise.all(resolvedMultiaddrs.map(async (nm) => {
-      return await this._resolve(nm)
+      return await this._resolve(nm, options)
     }))
 
     const addrs = recursiveMultiaddrs.flat()
@@ -368,10 +368,10 @@ export class Dialer implements Startable, Initializable {
   /**
    * Resolve a given multiaddr. If this fails, an empty array will be returned
    */
-  async _resolveRecord (ma: Multiaddr): Promise<Multiaddr[]> {
+  async _resolveRecord (ma: Multiaddr, options: AbortOptions): Promise<Multiaddr[]> {
     try {
       ma = new Multiaddr(ma.toString()) // Use current multiaddr module
-      const multiaddrs = await ma.resolve()
+      const multiaddrs = await ma.resolve(options)
       return multiaddrs
     } catch (err) {
       log.error(`multiaddr ${ma.toString()} could not be resolved`, err)

package/src/connection-manager/index.ts

@@ -107,10 +107,17 @@ export interface ConnectionManagerInit {
   maxAddrsToDial?: number
 
   /**
-   * How long a dial attempt is allowed to take
+   * How long a dial attempt is allowed to take, including DNS resolution
+   * of the multiaddr, opening a socket and upgrading it to a Connection.
    */
   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.
+   */
+  inboundUpgradeTimeout: number
+
   /**
    * Number of max concurrent dials per peer
    */
@@ -146,6 +153,7 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
   private readonly latencyMonitor: LatencyMonitor
   private readonly startupReconnectTimeout: number
   private connectOnStartupController?: TimeoutController
+  private readonly dialTimeout: number
 
   constructor (init: ConnectionManagerInit) {
     super()
@@ -182,6 +190,7 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
     this.onDisconnect = this.onDisconnect.bind(this)
 
     this.startupReconnectTimeout = init.startupReconnectTimeout ?? STARTUP_RECONNECT_TIMEOUT
+    this.dialTimeout = init.dialTimeout ?? 30000
   }
 
   init (components: Components): void {
@@ -322,6 +331,11 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
         this.connectOnStartupController?.clear()
         this.connectOnStartupController = new TimeoutController(this.startupReconnectTimeout)
 
+        try {
+          // fails on node < 15.4
+          setMaxListeners?.(Infinity, this.connectOnStartupController.signal)
+        } catch {}
+
         await Promise.all(
           keepAlivePeers.map(async peer => {
             await this.openConnection(peer, {
@@ -333,6 +347,9 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
           })
         )
       })
+      .catch(err => {
+        log.error(err)
+      })
       .finally(() => {
         this.connectOnStartupController?.clear()
       })
@@ -486,7 +503,7 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
     return conns
   }
 
-  async openConnection (peerId: PeerId, options?: AbortOptions): Promise<Connection> {
+  async openConnection (peerId: PeerId, options: AbortOptions = {}): Promise<Connection> {
     log('dial to %p', peerId)
     const existingConnections = this.getConnections(peerId)
 
@@ -496,30 +513,48 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
       return existingConnections[0]
     }
 
-    const connection = await this.dialer.dial(peerId, options)
-    let peerConnections = this.connections.get(peerId.toString())
+    let timeoutController: TimeoutController | undefined
 
-    if (peerConnections == null) {
-      peerConnections = []
-      this.connections.set(peerId.toString(), peerConnections)
+    if (options?.signal == null) {
+      timeoutController = new TimeoutController(this.dialTimeout)
+      options.signal = timeoutController.signal
+
+      try {
+        // fails on node < 15.4
+        setMaxListeners?.(Infinity, timeoutController.signal)
+      } catch {}
     }
 
-    // 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
+    try {
+      const connection = await this.dialer.dial(peerId, options)
+      let peerConnections = this.connections.get(peerId.toString())
 
-    for (const conn of peerConnections) {
-      if (conn.id === connection.id) {
-        trackedConnection = true
+      if (peerConnections == null) {
+        peerConnections = []
+        this.connections.set(peerId.toString(), peerConnections)
       }
-    }
 
-    if (!trackedConnection) {
-      peerConnections.push(connection)
-    }
+      // 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)
+      }
 
-    return connection
+      return connection
+    } finally {
+      if (timeoutController != null) {
+        timeoutController.clear()
+      }
+    }
   }
 
   async closeConnections (peerId: PeerId): Promise<void> {

package/src/constants.ts

@@ -4,6 +4,11 @@
  */
 export const DIAL_TIMEOUT = 30e3
 
+/**
+ * How long in ms an inbound connection upgrade is allowed to take
+ */
+export const INBOUND_UPGRADE_TIMEOUT = 30e3
+
 /**
  * Maximum allowed concurrent dials
  */

package/src/fetch/index.ts

@@ -10,10 +10,11 @@ import type { Stream } from '@libp2p/interface-connection'
 import type { IncomingStreamData } from '@libp2p/interface-registrar'
 import type { Components } from '@libp2p/components'
 import type { AbortOptions } from '@libp2p/interfaces'
-import type { Duplex } from 'it-stream-types'
 import { abortableDuplex } from 'abortable-iterator'
 import { pipe } from 'it-pipe'
 import first from 'it-first'
+import { TimeoutController } from 'timeout-abort-controller'
+import { setMaxListeners } from 'events'
 
 const log = logger('libp2p:fetch')
 
@@ -21,6 +22,11 @@ export interface FetchServiceInit {
   protocolPrefix: string
   maxInboundStreams: number
   maxOutboundStreams: number
+
+  /**
+   * How long we should wait for a remote peer to send any data
+   */
+  timeout: number
 }
 
 export interface HandleMessageOptions {
@@ -86,15 +92,29 @@ export class FetchService implements Startable {
     log('dialing %s to %p', this.protocol, peer)
 
     const connection = await this.components.getConnectionManager().openConnection(peer, options)
-    const stream = await connection.newStream([this.protocol], options)
-    let source: Duplex<Uint8Array> = stream
-
-    // make stream abortable if AbortSignal passed
-    if (options.signal != null) {
-      source = abortableDuplex(stream, options.signal)
+    let timeoutController
+    let signal = options.signal
+    let stream: Stream | undefined
+
+    // create a timeout if no abort signal passed
+    if (signal == null) {
+      timeoutController = new TimeoutController(this.init.timeout)
+      signal = timeoutController.signal
+
+      try {
+        // fails on node < 15.4
+        setMaxListeners?.(Infinity, timeoutController.signal)
+      } catch {}
     }
 
     try {
+      stream = await connection.newStream([this.protocol], {
+        signal
+      })
+
+      // make stream abortable
+      const source = abortableDuplex(stream, signal)
+
       const result = await pipe(
         [FetchRequest.encode({ identifier: key })],
         lp.encode(),
@@ -129,7 +149,13 @@ export class FetchService implements Startable {
 
       return result ?? null
     } finally {
-      stream.close()
+      if (timeoutController != null) {
+        timeoutController.clear()
+      }
+
+      if (stream != null) {
+        stream.close()
+      }
     }
   }
 

package/src/fetch/pb/proto.ts

@@ -1,7 +1,8 @@
 /* eslint-disable import/export */
 /* eslint-disable @typescript-eslint/no-namespace */
 
-import { encodeMessage, decodeMessage, message, string, enumeration, bytes } from 'protons-runtime'
+import { encodeMessage, decodeMessage, message, enumeration } from 'protons-runtime'
+import type { Uint8ArrayList } from 'uint8arraylist'
 import type { Codec } from 'protons-runtime'
 
 export interface FetchRequest {
@@ -9,17 +10,59 @@ export interface FetchRequest {
 }
 
 export namespace FetchRequest {
+  let _codec: Codec<FetchRequest>
+
   export const codec = (): Codec<FetchRequest> => {
-    return message<FetchRequest>({
-      1: { name: 'identifier', codec: string }
-    })
+    if (_codec == null) {
+      _codec = message<FetchRequest>((obj, writer, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          writer.fork()
+        }
+
+        if (obj.identifier != null) {
+          writer.uint32(10)
+          writer.string(obj.identifier)
+        } else {
+          throw new Error('Protocol error: required field "identifier" was not found in object')
+        }
+
+        if (opts.lengthDelimited !== false) {
+          writer.ldelim()
+        }
+      }, (reader, length) => {
+        const obj: any = {}
+
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1:
+              obj.identifier = reader.string()
+              break
+            default:
+              reader.skipType(tag & 7)
+              break
+          }
+        }
+
+        if (obj.identifier == null) {
+          throw new Error('Protocol error: value for required field "identifier" was not found in protobuf')
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
   }
 
   export const encode = (obj: FetchRequest): Uint8Array => {
     return encodeMessage(obj, FetchRequest.codec())
   }
 
-  export const decode = (buf: Uint8Array): FetchRequest => {
+  export const decode = (buf: Uint8Array | Uint8ArrayList): FetchRequest => {
     return decodeMessage(buf, FetchRequest.codec())
   }
 }
@@ -44,22 +87,77 @@ export namespace FetchResponse {
 
   export namespace StatusCode {
     export const codec = () => {
-      return enumeration<typeof StatusCode>(__StatusCodeValues)
+      return enumeration<StatusCode>(__StatusCodeValues)
     }
   }
 
+  let _codec: Codec<FetchResponse>
+
   export const codec = (): Codec<FetchResponse> => {
-    return message<FetchResponse>({
-      1: { name: 'status', codec: FetchResponse.StatusCode.codec() },
-      2: { name: 'data', codec: bytes }
-    })
+    if (_codec == null) {
+      _codec = message<FetchResponse>((obj, writer, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          writer.fork()
+        }
+
+        if (obj.status != null) {
+          writer.uint32(8)
+          FetchResponse.StatusCode.codec().encode(obj.status, writer)
+        } else {
+          throw new Error('Protocol error: required field "status" was not found in object')
+        }
+
+        if (obj.data != null) {
+          writer.uint32(18)
+          writer.bytes(obj.data)
+        } else {
+          throw new Error('Protocol error: required field "data" was not found in object')
+        }
+
+        if (opts.lengthDelimited !== false) {
+          writer.ldelim()
+        }
+      }, (reader, length) => {
+        const obj: any = {}
+
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1:
+              obj.status = FetchResponse.StatusCode.codec().decode(reader)
+              break
+            case 2:
+              obj.data = reader.bytes()
+              break
+            default:
+              reader.skipType(tag & 7)
+              break
+          }
+        }
+
+        if (obj.status == null) {
+          throw new Error('Protocol error: value for required field "status" was not found in protobuf')
+        }
+
+        if (obj.data == null) {
+          throw new Error('Protocol error: value for required field "data" was not found in protobuf')
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
   }
 
   export const encode = (obj: FetchResponse): Uint8Array => {
     return encodeMessage(obj, FetchResponse.codec())
   }
 
-  export const decode = (buf: Uint8Array): FetchResponse => {
+  export const decode = (buf: Uint8Array | Uint8ArrayList): FetchResponse => {
     return decodeMessage(buf, FetchResponse.codec())
   }
 }

package/src/identify/index.ts

@@ -26,13 +26,10 @@ import type { Components } from '@libp2p/components'
 import { TimeoutController } from 'timeout-abort-controller'
 import type { AbortOptions } from '@libp2p/interfaces'
 import { abortableDuplex } from 'abortable-iterator'
-import type { Duplex } from 'it-stream-types'
+import { setMaxListeners } from 'events'
 
 const log = logger('libp2p:identify')
 
-// https://github.com/libp2p/go-libp2p/blob/8d2e54e1637041d5cf4fac1e531287560bd1f4ac/p2p/protocol/identify/id.go#L48
-const IDENTIFY_TIMEOUT = 60000
-
 // https://github.com/libp2p/go-libp2p/blob/8d2e54e1637041d5cf4fac1e531287560bd1f4ac/p2p/protocol/identify/id.go#L52
 const MAX_IDENTIFY_MESSAGE_SIZE = 1024 * 8
 
@@ -54,7 +51,7 @@ export interface IdentifyServiceInit {
   /**
    * How long we should wait for a remote peer to send their identify response
    */
-  timeout?: number
+  timeout: number
 
   /**
    * Identify responses larger than this in bytes will be rejected (default: 8192)
@@ -167,8 +164,13 @@ export class IdentifyService implements Startable {
     const protocols = await this.components.getPeerStore().protoBook.get(this.components.getPeerId())
 
     const pushes = connections.map(async connection => {
-      const timeoutController = new TimeoutController(this.init.timeout ?? IDENTIFY_TIMEOUT)
       let stream: Stream | undefined
+      const timeoutController = new TimeoutController(this.init.timeout)
+
+      try {
+        // fails on node < 15.4
+        setMaxListeners?.(Infinity, timeoutController.signal)
+      } catch {}
 
       try {
         stream = await connection.newStream([this.identifyPushProtocolStr], {
@@ -176,7 +178,7 @@ export class IdentifyService implements Startable {
         })
 
         // make stream abortable
-        const source: Duplex<Uint8Array> = abortableDuplex(stream, timeoutController.signal)
+        const source = abortableDuplex(stream, timeoutController.signal)
 
         await pipe(
           [Identify.encode({
@@ -229,21 +231,29 @@ export class IdentifyService implements Startable {
   }
 
   async _identify (connection: Connection, options: AbortOptions = {}): Promise<Identify> {
-    const stream = await connection.newStream([this.identifyProtocolStr], options)
-    let source: Duplex<Uint8Array> = stream
     let timeoutController
     let signal = options.signal
+    let stream: Stream | undefined
 
     // create a timeout if no abort signal passed
     if (signal == null) {
-      timeoutController = new TimeoutController(this.init.timeout ?? IDENTIFY_TIMEOUT)
+      timeoutController = new TimeoutController(this.init.timeout)
       signal = timeoutController.signal
-    }
 
-    // make stream abortable if AbortSignal passed
-    source = abortableDuplex(stream, signal)
+      try {
+        // fails on node < 15.4
+        setMaxListeners?.(Infinity, timeoutController.signal)
+      } catch {}
+    }
 
     try {
+      stream = await connection.newStream([this.identifyProtocolStr], {
+        signal
+      })
+
+      // make stream abortable
+      const source = abortableDuplex(stream, signal)
+
       const data = await pipe(
         [],
         source,
@@ -267,7 +277,9 @@ export class IdentifyService implements Startable {
         timeoutController.clear()
       }
 
-      stream.close()
+      if (stream != null) {
+        stream.close()
+      }
     }
   }
 
@@ -370,7 +382,12 @@ export class IdentifyService implements Startable {
    */
   async _handleIdentify (data: IncomingStreamData) {
     const { connection, stream } = data
-    const timeoutController = new TimeoutController(this.init.timeout ?? IDENTIFY_TIMEOUT)
+    const timeoutController = new TimeoutController(this.init.timeout)
+
+    try {
+      // fails on node < 15.4
+      setMaxListeners?.(Infinity, timeoutController.signal)
+    } catch {}
 
     try {
       const publicKey = this.components.getPeerId().publicKey ?? new Uint8Array(0)
@@ -386,7 +403,7 @@ export class IdentifyService implements Startable {
 
         const envelope = await RecordEnvelope.seal(peerRecord, this.components.getPeerId())
         await this.components.getPeerStore().addressBook.consumePeerRecord(envelope)
-        signedPeerRecord = envelope.marshal()
+        signedPeerRecord = envelope.marshal().subarray()
       }
 
       const message = Identify.encode({
@@ -400,7 +417,7 @@ export class IdentifyService implements Startable {
       })
 
       // make stream abortable
-      const source: Duplex<Uint8Array> = abortableDuplex(stream, timeoutController.signal)
+      const source = abortableDuplex(stream, timeoutController.signal)
 
       await pipe(
         [message],
@@ -421,12 +438,17 @@ export class IdentifyService implements Startable {
    */
   async _handlePush (data: IncomingStreamData) {
     const { connection, stream } = data
-    const timeoutController = new TimeoutController(this.init.timeout ?? IDENTIFY_TIMEOUT)
+    const timeoutController = new TimeoutController(this.init.timeout)
+
+    try {
+      // fails on node < 15.4
+      setMaxListeners?.(Infinity, timeoutController.signal)
+    } catch {}
 
     let message: Identify | undefined
     try {
       // make stream abortable
-      const source: Duplex<Uint8Array> = abortableDuplex(stream, timeoutController.signal)
+      const source = abortableDuplex(stream, timeoutController.signal)
 
       const data = await pipe(
         [],