@libp2p/tcp 8.0.13 → 9.0.0

package/src/listener.ts

@@ -1,7 +1,5 @@
 import net from 'net'
-import { CodeError } from '@libp2p/interface/errors'
-import { TypedEventEmitter, CustomEvent } from '@libp2p/interface/events'
-import { logger } from '@libp2p/logger'
+import { CodeError, TypedEventEmitter, CustomEvent } from '@libp2p/interface'
 import { CODE_P2P } from './constants.js'
 import { toMultiaddrConnection } from './socket-to-conn.js'
 import {
@@ -10,21 +8,17 @@ import {
   type NetConfig
 } from './utils.js'
 import type { TCPCreateListenerOptions } from './index.js'
-import type { MultiaddrConnection, Connection } from '@libp2p/interface/connection'
-import type { CounterGroup, MetricGroup, Metrics } from '@libp2p/interface/metrics'
-import type { Listener, ListenerEvents, Upgrader } from '@libp2p/interface/transport'
+import type { ComponentLogger, Logger, LoggerOptions, MultiaddrConnection, Connection, CounterGroup, MetricGroup, Metrics, Listener, ListenerEvents, Upgrader } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
-const log = logger('libp2p:tcp:listener')
-
 /**
  * Attempts to close the given maConn. If a failure occurs, it will be logged
  */
-async function attemptClose (maConn: MultiaddrConnection): Promise<void> {
+async function attemptClose (maConn: MultiaddrConnection, options: LoggerOptions): Promise<void> {
   try {
     await maConn.close()
   } catch (err) {
-    log.error('an error occurred closing the connection', err)
+    options.log.error('an error occurred closing the connection', err)
   }
 }
 
@@ -45,6 +39,7 @@ interface Context extends TCPCreateListenerOptions {
   backlog?: number
   metrics?: Metrics
   closeServerOnMaxConnections?: CloseServerOnMaxConnectionsOpts
+  logger: ComponentLogger
 }
 
 export interface TCPListenerMetrics {
@@ -78,12 +73,15 @@ export class TCPListener extends TypedEventEmitter<ListenerEvents> implements Li
   private status: Status = { code: TCPListenerStatusCode.INACTIVE }
   private metrics?: TCPListenerMetrics
   private addr: string
+  private readonly log: Logger
 
   constructor (private readonly context: Context) {
     super()
 
     context.keepAlive = context.keepAlive ?? true
+    context.noDelay = context.noDelay ?? true
 
+    this.log = context.logger.forComponent('libp2p:tcp:listener')
     this.addr = 'unknown'
     this.server = net.createServer(context, this.onSocket.bind(this))
 
@@ -172,7 +170,7 @@ export class TCPListener extends TypedEventEmitter<ListenerEvents> implements Li
     }
     // Avoid uncaught errors caused by unstable connections
     socket.on('error', err => {
-      log('socket error', err)
+      this.log('socket error', err)
       this.metrics?.events.increment({ [`${this.addr} error`]: true })
     })
 
@@ -183,19 +181,20 @@ export class TCPListener extends TypedEventEmitter<ListenerEvents> implements Li
         socketInactivityTimeout: this.context.socketInactivityTimeout,
         socketCloseTimeout: this.context.socketCloseTimeout,
         metrics: this.metrics?.events,
-        metricPrefix: `${this.addr} `
+        metricPrefix: `${this.addr} `,
+        logger: this.context.logger
       })
     } catch (err) {
-      log.error('inbound connection failed', err)
+      this.log.error('inbound connection failed', err)
       this.metrics?.errors.increment({ [`${this.addr} inbound_to_connection`]: true })
       return
     }
 
-    log('new inbound connection %s', maConn.remoteAddr)
+    this.log('new inbound connection %s', maConn.remoteAddr)
     try {
       this.context.upgrader.upgradeInbound(maConn)
         .then((conn) => {
-          log('inbound connection upgraded %s', maConn.remoteAddr)
+          this.log('inbound connection upgraded %s', maConn.remoteAddr)
           this.connections.add(maConn)
 
           socket.once('close', () => {
@@ -210,7 +209,7 @@ export class TCPListener extends TypedEventEmitter<ListenerEvents> implements Li
               // we can do. resume() will be called again every time a connection is dropped, which
               // acts as an eventual retry mechanism. onListenError allows the consumer act on this.
               this.resume().catch(e => {
-                log.error('error attempting to listen server once connection count under limit', e)
+                this.log.error('error attempting to listen server once connection count under limit', e)
                 this.context.closeServerOnMaxConnections?.onListenError?.(e as Error)
               })
             }
@@ -225,27 +224,31 @@ export class TCPListener extends TypedEventEmitter<ListenerEvents> implements Li
             this.connections.size >= this.context.closeServerOnMaxConnections.closeAbove
           ) {
             this.pause(false).catch(e => {
-              log.error('error attempting to close server once connection count over limit', e)
+              this.log.error('error attempting to close server once connection count over limit', e)
             })
           }
 
           this.dispatchEvent(new CustomEvent<Connection>('connection', { detail: conn }))
         })
         .catch(async err => {
-          log.error('inbound connection failed', err)
+          this.log.error('inbound connection failed', err)
           this.metrics?.errors.increment({ [`${this.addr} inbound_upgrade`]: true })
 
-          await attemptClose(maConn)
+          await attemptClose(maConn, {
+            log: this.log
+          })
         })
         .catch(err => {
-          log.error('closing inbound connection failed', err)
+          this.log.error('closing inbound connection failed', err)
         })
     } catch (err) {
-      log.error('inbound connection failed', err)
+      this.log.error('inbound connection failed', err)
 
-      attemptClose(maConn)
+      attemptClose(maConn, {
+        log: this.log
+      })
         .catch(err => {
-          log.error('closing inbound connection failed', err)
+          this.log.error('closing inbound connection failed', err)
           this.metrics?.errors.increment({ [`${this.addr} inbound_closing_failed`]: true })
         })
     }
@@ -276,7 +279,7 @@ export class TCPListener extends TypedEventEmitter<ListenerEvents> implements Li
           addrs = addrs.concat(getMultiaddrs('ip6', address.address, address.port))
         }
       } catch (err) {
-        log.error('could not turn %s:%s into multiaddr', address.address, address.port, err)
+        this.log.error('could not turn %s:%s into multiaddr', address.address, address.port, err)
       }
     }
 
@@ -310,9 +313,11 @@ export class TCPListener extends TypedEventEmitter<ListenerEvents> implements Li
   async close (): Promise<void> {
     // Close connections and server the same time to avoid any race condition
     await Promise.all([
-      Promise.all(Array.from(this.connections.values()).map(async maConn => attemptClose(maConn))),
+      Promise.all(Array.from(this.connections.values()).map(async maConn => attemptClose(maConn, {
+        log: this.log
+      }))),
       this.pause(true).catch(e => {
-        log.error('error attempting to close server once connection count over limit', e)
+        this.log.error('error attempting to close server once connection count over limit', e)
       })
     ])
   }
@@ -334,7 +339,7 @@ export class TCPListener extends TypedEventEmitter<ListenerEvents> implements Li
     })
 
     this.status = { ...this.status, code: TCPListenerStatusCode.ACTIVE }
-    log('Listening on %s', this.server.address())
+    this.log('Listening on %s', this.server.address())
   }
 
   private async pause (permanent: boolean): Promise<void> {
@@ -347,7 +352,7 @@ export class TCPListener extends TypedEventEmitter<ListenerEvents> implements Li
       return
     }
 
-    log('Closing server on %s', this.server.address())
+    this.log('Closing server on %s', this.server.address())
 
     // NodeJS implementation tracks listening status with `this._handle` property.
     // - Server.close() sets this._handle to null immediately. If this._handle is null, ERR_SERVER_NOT_RUNNING is thrown

package/src/socket-to-conn.ts

@@ -1,17 +1,13 @@
-import { CodeError } from '@libp2p/interface/errors'
-import { logger } from '@libp2p/logger'
+import { CodeError } from '@libp2p/interface'
 import { ipPortToMultiaddr as toMultiaddr } from '@libp2p/utils/ip-port-to-multiaddr'
 // @ts-expect-error no types
 import toIterable from 'stream-to-it'
 import { CLOSE_TIMEOUT, SOCKET_TIMEOUT } from './constants.js'
 import { multiaddrToNetConfig } from './utils.js'
-import type { MultiaddrConnection } from '@libp2p/interface/connection'
-import type { CounterGroup } from '@libp2p/interface/metrics'
+import type { ComponentLogger, MultiaddrConnection, CounterGroup } from '@libp2p/interface'
 import type { AbortOptions, Multiaddr } from '@multiformats/multiaddr'
 import type { Socket } from 'net'
 
-const log = logger('libp2p:tcp:socket')
-
 interface ToConnectionOptions {
   listeningAddr?: Multiaddr
   remoteAddr?: Multiaddr
@@ -20,6 +16,7 @@ interface ToConnectionOptions {
   socketCloseTimeout?: number
   metrics?: CounterGroup
   metricPrefix?: string
+  logger: ComponentLogger
 }
 
 /**
@@ -27,6 +24,7 @@ interface ToConnectionOptions {
  * https://github.com/libp2p/interface-transport#multiaddrconnection
  */
 export const toMultiaddrConnection = (socket: Socket, options: ToConnectionOptions): MultiaddrConnection => {
+  const log = options.logger.forComponent('libp2p:tcp:socket')
   const metrics = options.metrics
   const metricPrefix = options.metricPrefix ?? ''
   const inactivityTimeout = options.socketInactivityTimeout ?? SOCKET_TIMEOUT
@@ -98,7 +96,15 @@ export const toMultiaddrConnection = (socket: Socket, options: ToConnectionOptio
   const maConn: MultiaddrConnection = {
     async sink (source) {
       try {
-        await sink(source)
+        await sink((async function * () {
+          for await (const buf of source) {
+            if (buf instanceof Uint8Array) {
+              yield buf
+            } else {
+              yield buf.subarray()
+            }
+          }
+        })())
       } catch (err: any) {
         // If aborted we can safely ignore
         if (err.type !== 'aborted') {
@@ -182,7 +188,9 @@ export const toMultiaddrConnection = (socket: Socket, options: ToConnectionOptio
       log('%s socket abort due to error', lOptsStr, err)
 
       socket.destroy(err)
-    }
+    },
+
+    log
   }
 
   return maConn

package/src/utils.ts

@@ -22,7 +22,7 @@ export function multiaddrToNetConfig (addr: Multiaddr, config: NetConfig = {}):
   }
 
   // tcp listening
-  return { ...addr.toOptions(), ...config }
+  return { ...config, ...addr.toOptions() }
 }
 
 export function getMultiaddrs (proto: 'ip4' | 'ip6', ip: string, port: number): Multiaddr[] {