libp2p 0.46.19-fb8a6f188 → 0.46.19

package/src/upgrader.ts

@@ -1,12 +1,13 @@
 import { CodeError } from '@libp2p/interface/errors'
 import { setMaxListeners } from '@libp2p/interface/events'
+import { logger } from '@libp2p/logger'
 import * as mss from '@libp2p/multistream-select'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { createConnection } from './connection/index.js'
 import { INBOUND_UPGRADE_TIMEOUT } from './connection-manager/constants.js'
 import { codes } from './errors.js'
 import { DEFAULT_MAX_INBOUND_STREAMS, DEFAULT_MAX_OUTBOUND_STREAMS } from './registrar.js'
-import type { Libp2pEvents, AbortOptions, ComponentLogger, Logger } from '@libp2p/interface'
+import type { Libp2pEvents, AbortOptions } from '@libp2p/interface'
 import type { MultiaddrConnection, Connection, Stream, ConnectionProtector, NewStreamOptions } from '@libp2p/interface/connection'
 import type { ConnectionEncrypter, SecuredConnection } from '@libp2p/interface/connection-encrypter'
 import type { ConnectionGater } from '@libp2p/interface/connection-gater'
@@ -20,6 +21,8 @@ import type { ConnectionManager } from '@libp2p/interface-internal/connection-ma
 import type { Registrar } from '@libp2p/interface-internal/registrar'
 import type { Duplex, Source } from 'it-stream-types'
 
+const log = logger('libp2p:upgrader')
+
 interface CreateConnectionOptions {
   cryptoProtocol: string
   direction: 'inbound' | 'outbound'
@@ -102,7 +105,6 @@ export interface DefaultUpgraderComponents {
   registrar: Registrar
   peerStore: PeerStore
   events: TypedEventTarget<Libp2pEvents>
-  logger: ComponentLogger
 }
 
 type EncryptedConn = Duplex<AsyncGenerator<Uint8Array, any, unknown>, Source<Uint8Array>, Promise<void>>
@@ -115,12 +117,10 @@ export class DefaultUpgrader implements Upgrader {
   private readonly muxers: Map<string, StreamMuxerFactory>
   private readonly inboundUpgradeTimeout: number
   private readonly events: TypedEventTarget<Libp2pEvents>
-  readonly #log: Logger
 
   constructor (components: DefaultUpgraderComponents, init: UpgraderInit) {
     this.components = components
     this.connectionEncryption = new Map()
-    this.#log = components.logger.forComponent('libp2p:upgrader')
 
     init.connectionEncryption.forEach(encrypter => {
       this.connectionEncryption.set(encrypter.protocol, encrypter)
@@ -179,7 +179,7 @@ export class DefaultUpgrader implements Upgrader {
 
       this.components.metrics?.trackMultiaddrConnection(maConn)
 
-      this.#log('starting the inbound connection upgrade')
+      log('starting the inbound connection upgrade')
 
       // Protect
       let protectedConn = maConn
@@ -188,7 +188,7 @@ export class DefaultUpgrader implements Upgrader {
         const protector = this.components.connectionProtector
 
         if (protector != null) {
-          this.#log('protecting the inbound connection')
+          log('protecting the inbound connection')
           protectedConn = await protector.protect(maConn)
         }
       }
@@ -235,13 +235,13 @@ export class DefaultUpgrader implements Upgrader {
           upgradedConn = multiplexed.stream
         }
       } catch (err: any) {
-        this.#log.error('Failed to upgrade inbound connection', err)
+        log.error('Failed to upgrade inbound connection', err)
         throw err
       }
 
       await this.shouldBlockConnection(remotePeer, maConn, 'denyInboundUpgradedConnection')
 
-      this.#log('Successfully upgraded inbound connection')
+      log('Successfully upgraded inbound connection')
 
       return this._createConnection({
         cryptoProtocol,
@@ -280,7 +280,7 @@ export class DefaultUpgrader implements Upgrader {
 
     this.components.metrics?.trackMultiaddrConnection(maConn)
 
-    this.#log('Starting the outbound connection upgrade')
+    log('Starting the outbound connection upgrade')
 
     // If the transport natively supports encryption, skip connection
     // protector and encryption
@@ -333,14 +333,14 @@ export class DefaultUpgrader implements Upgrader {
         upgradedConn = multiplexed.stream
       }
     } catch (err: any) {
-      this.#log.error('Failed to upgrade outbound connection', err)
+      log.error('Failed to upgrade outbound connection', err)
       await maConn.close(err)
       throw err
     }
 
     await this.shouldBlockConnection(remotePeer, maConn, 'denyOutboundUpgradedConnection')
 
-    this.#log('Successfully upgraded outbound connection')
+    log('Successfully upgraded outbound connection')
 
     return this._createConnection({
       cryptoProtocol,
@@ -385,7 +385,7 @@ export class DefaultUpgrader implements Upgrader {
             .then(async () => {
               const protocols = this.components.registrar.getProtocols()
               const { stream, protocol } = await mss.handle(muxedStream, protocols)
-              this.#log('%s: incoming stream opened on %s', direction, protocol)
+              log('%s: incoming stream opened on %s', direction, protocol)
 
               if (connection == null) {
                 return
@@ -418,7 +418,7 @@ export class DefaultUpgrader implements Upgrader {
               this._onStream({ connection, stream: muxedStream, protocol })
             })
             .catch(async err => {
-              this.#log.error(err)
+              log.error(err)
 
               if (muxedStream.timeline.close == null) {
                 await muxedStream.close()
@@ -432,12 +432,12 @@ export class DefaultUpgrader implements Upgrader {
           throw new CodeError('Stream is not multiplexed', codes.ERR_MUXER_UNAVAILABLE)
         }
 
-        this.#log('%s-%s: starting new stream on %s', connection.id, direction, protocols)
+        log('%s-%s: starting new stream on %s', connection.id, direction, protocols)
         const muxedStream = await muxer.newStream()
 
         try {
           if (options.signal == null) {
-            this.#log('No abort signal was passed while trying to negotiate protocols %s falling back to default timeout', protocols)
+            log('No abort signal was passed while trying to negotiate protocols %s falling back to default timeout', protocols)
 
             options.signal = AbortSignal.timeout(30000)
 
@@ -472,7 +472,7 @@ export class DefaultUpgrader implements Upgrader {
 
           return muxedStream
         } catch (err: any) {
-          this.#log.error('could not create new stream for protocols %s on connection with address %a', protocols, connection.remoteAddr, err)
+          log.error('could not create new stream for protocols %s on connection with address %a', protocols, connection.remoteAddr, err)
 
           if (muxedStream.timeline.close == null) {
             muxedStream.abort(err)
@@ -491,7 +491,7 @@ export class DefaultUpgrader implements Upgrader {
         muxer.sink(upgradedConn.source),
         upgradedConn.sink(muxer.source)
       ]).catch(err => {
-        this.#log.error(err)
+        log.error(err)
       })
     }
 
@@ -506,14 +506,14 @@ export class DefaultUpgrader implements Upgrader {
                 await connection.close()
               }
             } catch (err: any) {
-              this.#log.error(err)
+              log.error(err)
             } finally {
               this.events.safeDispatchEvent('connection:close', {
                 detail: connection
               })
             }
           })().catch(err => {
-            this.#log.error(err)
+            log.error(err)
           })
         }
 
@@ -536,20 +536,19 @@ export class DefaultUpgrader implements Upgrader {
       multiplexer: muxer?.protocol,
       encryption: cryptoProtocol,
       transient,
-      logger: this.components.logger,
       newStream: newStream ?? errConnectionNotMultiplexed,
       getStreams: () => { if (muxer != null) { return muxer.streams } else { return [] } },
       close: async (options?: AbortOptions) => {
         // Ensure remaining streams are closed gracefully
         if (muxer != null) {
-          this.#log.trace('close muxer')
+          log.trace('close muxer')
           await muxer.close(options)
         }
 
-        this.#log.trace('close maconn')
+        log.trace('close maconn')
         // close the underlying transport
         await maConn.close(options)
-        this.#log.trace('closed maconn')
+        log.trace('closed maconn')
       },
       abort: (err) => {
         maConn.abort(err)
@@ -586,7 +585,7 @@ export class DefaultUpgrader implements Upgrader {
    */
   async _encryptInbound (connection: Duplex<AsyncGenerator<Uint8Array>, Source<Uint8Array>>): Promise<CryptoResult> {
     const protocols = Array.from(this.connectionEncryption.keys())
-    this.#log('handling inbound crypto protocol selection', protocols)
+    log('handling inbound crypto protocol selection', protocols)
 
     try {
       const { stream, protocol } = await mss.handle(connection, protocols, {
@@ -598,7 +597,7 @@ export class DefaultUpgrader implements Upgrader {
         throw new Error(`no crypto module found for ${protocol}`)
       }
 
-      this.#log('encrypting inbound connection...')
+      log('encrypting inbound connection...')
 
       return {
         ...await encrypter.secureInbound(this.components.peerId, stream),
@@ -615,7 +614,7 @@ export class DefaultUpgrader implements Upgrader {
    */
   async _encryptOutbound (connection: MultiaddrConnection, remotePeerId?: PeerId): Promise<CryptoResult> {
     const protocols = Array.from(this.connectionEncryption.keys())
-    this.#log('selecting outbound crypto protocol', protocols)
+    log('selecting outbound crypto protocol', protocols)
 
     try {
       const { stream, protocol } = await mss.select(connection, protocols, {
@@ -627,7 +626,7 @@ export class DefaultUpgrader implements Upgrader {
         throw new Error(`no crypto module found for ${protocol}`)
       }
 
-      this.#log('encrypting outbound connection to %p', remotePeerId)
+      log('encrypting outbound connection to %p', remotePeerId)
 
       return {
         ...await encrypter.secureOutbound(this.components.peerId, stream, remotePeerId),
@@ -644,17 +643,17 @@ export class DefaultUpgrader implements Upgrader {
    */
   async _multiplexOutbound (connection: MultiaddrConnection, muxers: Map<string, StreamMuxerFactory>): Promise<{ stream: Duplex<AsyncGenerator<Uint8Array>, Source<Uint8Array>, Promise<void>>, muxerFactory?: StreamMuxerFactory }> {
     const protocols = Array.from(muxers.keys())
-    this.#log('outbound selecting muxer %s', protocols)
+    log('outbound selecting muxer %s', protocols)
     try {
       const { stream, protocol } = await mss.select(connection, protocols, {
         writeBytes: true
       })
-      this.#log('%s selected as muxer protocol', protocol)
+      log('%s selected as muxer protocol', protocol)
       const muxerFactory = muxers.get(protocol)
 
       return { stream, muxerFactory }
     } catch (err: any) {
-      this.#log.error('error multiplexing outbound stream', err)
+      log.error('error multiplexing outbound stream', err)
       throw new CodeError(String(err), codes.ERR_MUXER_UNAVAILABLE)
     }
   }
@@ -665,7 +664,7 @@ export class DefaultUpgrader implements Upgrader {
    */
   async _multiplexInbound (connection: MultiaddrConnection, muxers: Map<string, StreamMuxerFactory>): Promise<{ stream: Duplex<AsyncGenerator<Uint8Array>, Source<Uint8Array>, Promise<void>>, muxerFactory?: StreamMuxerFactory }> {
     const protocols = Array.from(muxers.keys())
-    this.#log('inbound handling muxers %s', protocols)
+    log('inbound handling muxers %s', protocols)
     try {
       const { stream, protocol } = await mss.handle(connection, protocols, {
         writeBytes: true
@@ -674,7 +673,7 @@ export class DefaultUpgrader implements Upgrader {
 
       return { stream, muxerFactory }
     } catch (err: any) {
-      this.#log.error('error multiplexing inbound stream', err)
+      log.error('error multiplexing inbound stream', err)
       throw new CodeError(String(err), codes.ERR_MUXER_UNAVAILABLE)
     }
   }

package/src/version.ts

@@ -1,2 +1,2 @@
-export const version = '0.46.19-fb8a6f188'
+export const version = '0.46.19'
 export const name = 'libp2p'