@libp2p/tcp 10.0.6-24fa1d5af → 10.0.6-d9c7e0f7e

package/src/socket-to-conn.ts

@@ -1,14 +1,11 @@
-import { InvalidParametersError, TimeoutError } from '@libp2p/interface'
+import { AbortError, InvalidParametersError, TimeoutError } from '@libp2p/interface'
 import { ipPortToMultiaddr as toMultiaddr } from '@libp2p/utils/ip-port-to-multiaddr'
-import pDefer from 'p-defer'
-import { raceEvent } from 'race-event'
 import { duplex } from 'stream-to-it'
 import { CLOSE_TIMEOUT, SOCKET_TIMEOUT } from './constants.js'
 import { multiaddrToNetConfig } from './utils.js'
 import type { ComponentLogger, MultiaddrConnection, CounterGroup } from '@libp2p/interface'
 import type { AbortOptions, Multiaddr } from '@multiformats/multiaddr'
 import type { Socket } from 'net'
-import type { DeferredPromise } from 'p-defer'
 
 interface ToConnectionOptions {
   listeningAddr?: Multiaddr
@@ -19,7 +16,6 @@ interface ToConnectionOptions {
   metrics?: CounterGroup
   metricPrefix?: string
   logger: ComponentLogger
-  direction: 'inbound' | 'outbound'
 }
 
 /**
@@ -27,15 +23,12 @@ interface ToConnectionOptions {
  * https://github.com/libp2p/interface-transport#multiaddrconnection
  */
 export const toMultiaddrConnection = (socket: Socket, options: ToConnectionOptions): MultiaddrConnection => {
-  let closePromise: DeferredPromise<void>
+  let closePromise: Promise<void> | null = null
   const log = options.logger.forComponent('libp2p:tcp:socket')
-  const direction = options.direction
   const metrics = options.metrics
   const metricPrefix = options.metricPrefix ?? ''
   const inactivityTimeout = options.socketInactivityTimeout ?? SOCKET_TIMEOUT
   const closeTimeout = options.socketCloseTimeout ?? CLOSE_TIMEOUT
-  let timedout = false
-  let errored = false
 
   // Check if we are connected on a unix path
   if (options.listeningAddr?.getPath() != null) {
@@ -46,19 +39,6 @@ export const toMultiaddrConnection = (socket: Socket, options: ToConnectionOptio
     options.localAddr = options.remoteAddr
   }
 
-  // handle socket errors
-  socket.on('error', err => {
-    errored = true
-
-    if (!timedout) {
-      log.error('%s socket error - %e', direction, err)
-      metrics?.increment({ [`${metricPrefix}error`]: true })
-    }
-
-    socket.destroy()
-    maConn.timeline.close = Date.now()
-  })
-
   let remoteAddr: Multiaddr
 
   if (options.remoteAddr != null) {
@@ -79,37 +59,37 @@ export const toMultiaddrConnection = (socket: Socket, options: ToConnectionOptio
 
   // by default there is no timeout
   // https://nodejs.org/dist/latest-v16.x/docs/api/net.html#socketsettimeouttimeout-callback
-  socket.setTimeout(inactivityTimeout)
-
-  socket.once('timeout', () => {
-    timedout = true
-    log('%s %s socket read timeout', direction, lOptsStr)
+  socket.setTimeout(inactivityTimeout, () => {
+    log('%s socket read timeout', lOptsStr)
     metrics?.increment({ [`${metricPrefix}timeout`]: true })
 
+    // only destroy with an error if the remote has not sent the FIN message
+    let err: Error | undefined
+    if (socket.readable) {
+      err = new TimeoutError('Socket read timeout')
+    }
+
     // if the socket times out due to inactivity we must manually close the connection
     // https://nodejs.org/dist/latest-v16.x/docs/api/net.html#event-timeout
-    socket.destroy(new TimeoutError())
-    maConn.timeline.close = Date.now()
+    socket.destroy(err)
   })
 
   socket.once('close', () => {
-    // record metric for clean exit
-    if (!timedout && !errored) {
-      log('%s %s socket close', direction, lOptsStr)
-      metrics?.increment({ [`${metricPrefix}close`]: true })
-    }
+    log('%s socket close', lOptsStr)
+    metrics?.increment({ [`${metricPrefix}close`]: true })
 
     // In instances where `close` was not explicitly called,
     // such as an iterable stream ending, ensure we have set the close
     // timeline
-    socket.destroy()
-    maConn.timeline.close = Date.now()
+    if (maConn.timeline.close == null) {
+      maConn.timeline.close = Date.now()
+    }
   })
 
   socket.once('end', () => {
     // the remote sent a FIN packet which means no more data will be sent
     // https://nodejs.org/dist/latest-v16.x/docs/api/net.html#event-end
-    log('%s %s socket end', direction, lOptsStr)
+    log('%s socket end', lOptsStr)
     metrics?.increment({ [`${metricPrefix}end`]: true })
   })
 
@@ -131,7 +111,7 @@ export const toMultiaddrConnection = (socket: Socket, options: ToConnectionOptio
           // If the source errored the socket will already have been destroyed by
           // duplex(). If the socket errored it will already be
           // destroyed. There's nothing to do here except log the error & return.
-          log.error('%s %s error in sink - %e', direction, lOptsStr, err)
+          log.error('%s error in sink', lOptsStr, err)
         }
       }
 
@@ -148,66 +128,96 @@ export const toMultiaddrConnection = (socket: Socket, options: ToConnectionOptio
 
     async close (options: AbortOptions = {}) {
       if (socket.closed) {
-        log('the %s %s socket is already closed', direction, lOptsStr)
+        log('The %s socket is already closed', lOptsStr)
         return
       }
 
       if (socket.destroyed) {
-        log('the %s %s socket is already destroyed', direction, lOptsStr)
+        log('The %s socket is already destroyed', lOptsStr)
         return
       }
 
-      if (closePromise != null) {
-        return closePromise.promise
+      const abortSignalListener = (): void => {
+        socket.destroy(new AbortError('Destroying socket after timeout'))
       }
 
       try {
-        closePromise = pDefer()
+        if (closePromise != null) {
+          log('The %s socket is already closing', lOptsStr)
+          await closePromise
+          return
+        }
 
-        // close writable end of socket
-        socket.end()
+        if (options.signal == null) {
+          const signal = AbortSignal.timeout(closeTimeout)
 
-        // convert EventEmitter to EventTarget
-        const eventTarget = socketToEventTarget(socket)
+          options = {
+            ...options,
+            signal
+          }
+        }
 
-        // don't wait forever to close
-        const signal = options.signal ?? AbortSignal.timeout(closeTimeout)
+        options.signal?.addEventListener('abort', abortSignalListener)
 
-        // wait for any unsent data to be sent
-        if (socket.writableLength > 0) {
-          log('%s %s draining socket', direction, lOptsStr)
-          await raceEvent(eventTarget, 'drain', signal, {
-            errorEvent: 'error'
+        log('%s closing socket', lOptsStr)
+        closePromise = new Promise<void>((resolve, reject) => {
+          socket.once('close', () => {
+            // socket completely closed
+            log('%s socket closed', lOptsStr)
+            resolve()
           })
-          log('%s %s socket drained', direction, lOptsStr)
-        }
+          socket.once('error', (err: Error) => {
+            log('%s socket error', lOptsStr, err)
 
-        await Promise.all([
-          raceEvent(eventTarget, 'close', signal, {
-            errorEvent: 'error'
-          }),
+            if (!socket.destroyed) {
+              reject(err)
+            }
+            // if socket is destroyed, 'closed' event will be emitted later to resolve the promise
+          })
+
+          // shorten inactivity timeout
+          socket.setTimeout(closeTimeout)
+
+          // close writable end of the socket
+          socket.end()
+
+          if (socket.writableLength > 0) {
+            // there are outgoing bytes waiting to be sent
+            socket.once('drain', () => {
+              log('%s socket drained', lOptsStr)
 
-          // all bytes have been sent we can destroy the socket
-          socket.destroy()
-        ])
+              // all bytes have been sent we can destroy the socket (maybe) before the timeout
+              socket.destroy()
+            })
+          } else {
+            // nothing to send, destroy immediately, no need for the timeout
+            socket.destroy()
+          }
+        })
+
+        await closePromise
       } catch (err: any) {
         this.abort(err)
       } finally {
-        closePromise.resolve()
+        options.signal?.removeEventListener('abort', abortSignalListener)
       }
     },
 
     abort: (err: Error) => {
-      log('%s %s socket abort due to error - %e', direction, lOptsStr, err)
+      log('%s socket abort due to error', lOptsStr, err)
 
       // the abortSignalListener may already destroyed the socket with an error
-      socket.destroy()
+      if (!socket.destroyed) {
+        socket.destroy(err)
+      }
 
       // closing a socket is always asynchronous (must wait for "close" event)
       // but the tests expect this to be a synchronous operation so we have to
       // set the close time here. the tests should be refactored to reflect
       // reality.
-      maConn.timeline.close = Date.now()
+      if (maConn.timeline.close == null) {
+        maConn.timeline.close = Date.now()
+      }
     },
 
     log
@@ -215,17 +225,3 @@ export const toMultiaddrConnection = (socket: Socket, options: ToConnectionOptio
 
   return maConn
 }
-
-function socketToEventTarget (obj?: any): EventTarget {
-  const eventTarget = {
-    addEventListener: (type: any, cb: any) => {
-      obj.addListener(type, cb)
-    },
-    removeEventListener: (type: any, cb: any) => {
-      obj.removeListener(type, cb)
-    }
-  }
-
-  // @ts-expect-error partial implementation
-  return eventTarget
-}

package/src/tcp.ts

@@ -36,7 +36,7 @@ import { TCPListener } from './listener.js'
 import { toMultiaddrConnection } from './socket-to-conn.js'
 import { multiaddrToNetConfig } from './utils.js'
 import type { TCPComponents, TCPCreateListenerOptions, TCPDialEvents, TCPDialOptions, TCPMetrics, TCPOptions } from './index.js'
-import type { Logger, Connection, Transport, Listener, MultiaddrConnection } from '@libp2p/interface'
+import type { Logger, Connection, Transport, Listener } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { Socket, IpcSocketConnectOpts, TcpSocketConnectOpts } from 'net'
 
@@ -53,11 +53,7 @@ export class TCP implements Transport<TCPDialEvents> {
 
     if (components.metrics != null) {
       this.metrics = {
-        events: components.metrics.registerCounterGroup('libp2p_tcp_dialer_events_total', {
-          label: 'event',
-          help: 'Total count of TCP dialer events by type'
-        }),
-        errors: components.metrics.registerCounterGroup('libp2p_tcp_dialer_errors_total', {
+        dialerEvents: components.metrics.registerCounterGroup('libp2p_tcp_dialer_events_total', {
           label: 'event',
           help: 'Total count of TCP dialer events by type'
         })
@@ -80,28 +76,23 @@ export class TCP implements Transport<TCPDialEvents> {
     // options.signal destroys the socket before 'connect' event
     const socket = await this._connect(ma, options)
 
-    let maConn: MultiaddrConnection
+    // Avoid uncaught errors caused by unstable connections
+    socket.on('error', err => {
+      this.log('socket error', err)
+    })
 
-    try {
-      maConn = toMultiaddrConnection(socket, {
-        remoteAddr: ma,
-        socketInactivityTimeout: this.opts.outboundSocketInactivityTimeout,
-        socketCloseTimeout: this.opts.socketCloseTimeout,
-        metrics: this.metrics?.events,
-        logger: this.components.logger,
-        direction: 'outbound'
-      })
-    } catch (err: any) {
-      this.metrics?.errors.increment({ outbound_to_connection: true })
-      socket.destroy(err)
-      throw err
-    }
+    const maConn = toMultiaddrConnection(socket, {
+      remoteAddr: ma,
+      socketInactivityTimeout: this.opts.outboundSocketInactivityTimeout,
+      socketCloseTimeout: this.opts.socketCloseTimeout,
+      metrics: this.metrics?.dialerEvents,
+      logger: this.components.logger
+    })
 
     try {
       this.log('new outbound connection %s', maConn.remoteAddr)
       return await options.upgrader.upgradeOutbound(maConn, options)
     } catch (err: any) {
-      this.metrics?.errors.increment({ outbound_upgrade: true })
       this.log.error('error upgrading outbound connection', err)
       maConn.abort(err)
       throw err
@@ -112,8 +103,6 @@ export class TCP implements Transport<TCPDialEvents> {
     options.signal?.throwIfAborted()
     options.onProgress?.(new CustomProgressEvent('tcp:open-connection'))
 
-    let rawSocket: Socket
-
     return new Promise<Socket>((resolve, reject) => {
       const start = Date.now()
       const cOpts = multiaddrToNetConfig(ma, {
@@ -122,34 +111,35 @@ export class TCP implements Transport<TCPDialEvents> {
       }) as (IpcSocketConnectOpts & TcpSocketConnectOpts)
 
       this.log('dialing %a', ma)
-      rawSocket = net.connect(cOpts)
+      const rawSocket = net.connect(cOpts)
 
       const onError = (err: Error): void => {
-        this.log.error('dial to %a errored - %e', ma, err)
         const cOptsStr = cOpts.path ?? `${cOpts.host ?? ''}:${cOpts.port}`
         err.message = `connection error ${cOptsStr}: ${err.message}`
-        this.metrics?.events.increment({ error: true })
+        this.metrics?.dialerEvents.increment({ error: true })
+
         done(err)
       }
 
       const onTimeout = (): void => {
         this.log('connection timeout %a', ma)
-        this.metrics?.events.increment({ timeout: true })
+        this.metrics?.dialerEvents.increment({ timeout: true })
 
-        const err = new TimeoutError(`Connection timeout after ${Date.now() - start}ms`)
+        const err = new TimeoutError(`connection timeout after ${Date.now() - start}ms`)
         // Note: this will result in onError() being called
         rawSocket.emit('error', err)
       }
 
       const onConnect = (): void => {
         this.log('connection opened %a', ma)
-        this.metrics?.events.increment({ connect: true })
+        this.metrics?.dialerEvents.increment({ connect: true })
         done()
       }
 
       const onAbort = (): void => {
         this.log('connection aborted %a', ma)
-        this.metrics?.events.increment({ abort: true })
+        this.metrics?.dialerEvents.increment({ abort: true })
+        rawSocket.destroy()
         done(new AbortError())
       }
 
@@ -177,10 +167,6 @@ export class TCP implements Transport<TCPDialEvents> {
         options.signal.addEventListener('abort', onAbort)
       }
     })
-      .catch(err => {
-        rawSocket?.destroy()
-        throw err
-      })
   }
 
   /**