@libp2p/tcp 1.0.0 → 1.0.4

package/package.json

@@ -1,86 +1,155 @@
 {
   "name": "@libp2p/tcp",
-  "version": "1.0.0",
+  "version": "1.0.4",
   "description": "Node.js implementation of the TCP module that libp2p uses, which implements the interface-connection and interface-transport interfaces",
-  "main": "./dist/src/index.js",
+  "license": "Apache-2.0 OR MIT",
+  "homepage": "https://github.com/libp2p/js-libp2p-tcp#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/libp2p/js-libp2p-tcp.git"
+  },
+  "bugs": {
+    "url": "https://github.com/libp2p/js-libp2p-tcp/issues"
+  },
+  "keywords": [
+    "IPFS",
+    "TCP",
+    "libp2p",
+    "network",
+    "p2p",
+    "peer",
+    "peer-to-peer"
+  ],
+  "engines": {
+    "node": ">=16.0.0",
+    "npm": ">=7.0.0"
+  },
   "type": "module",
+  "types": "./dist/src/index.d.ts",
+  "files": [
+    "src",
+    "dist/src",
+    "!dist/test",
+    "!**/*.tsbuildinfo"
+  ],
   "exports": {
     ".": {
       "import": "./dist/src/index.js"
     }
   },
+  "eslintConfig": {
+    "extends": "ipfs",
+    "parserOptions": {
+      "sourceType": "module"
+    }
+  },
+  "release": {
+    "branches": [
+      "master"
+    ],
+    "plugins": [
+      [
+        "@semantic-release/commit-analyzer",
+        {
+          "preset": "conventionalcommits",
+          "releaseRules": [
+            {
+              "breaking": true,
+              "release": "major"
+            },
+            {
+              "revert": true,
+              "release": "patch"
+            },
+            {
+              "type": "feat",
+              "release": "minor"
+            },
+            {
+              "type": "fix",
+              "release": "patch"
+            },
+            {
+              "type": "chore",
+              "release": "patch"
+            },
+            {
+              "type": "docs",
+              "release": "patch"
+            },
+            {
+              "type": "test",
+              "release": "patch"
+            },
+            {
+              "scope": "no-release",
+              "release": false
+            }
+          ]
+        }
+      ],
+      [
+        "@semantic-release/release-notes-generator",
+        {
+          "preset": "conventionalcommits",
+          "presetConfig": {
+            "types": [
+              {
+                "type": "feat",
+                "section": "Features"
+              },
+              {
+                "type": "fix",
+                "section": "Bug Fixes"
+              },
+              {
+                "type": "chore",
+                "section": "Trivial Changes"
+              },
+              {
+                "type": "docs",
+                "section": "Trivial Changes"
+              },
+              {
+                "type": "test",
+                "section": "Tests"
+              }
+            ]
+          }
+        }
+      ],
+      "@semantic-release/changelog",
+      "@semantic-release/npm",
+      "@semantic-release/github",
+      "@semantic-release/git"
+    ]
+  },
   "scripts": {
     "lint": "aegir lint",
     "dep-check": "aegir dep-check dist/src/**/*.js dist/test/**/*.js",
     "build": "tsc",
     "pretest": "npm run build",
-    "test": "aegir test -f ./dist/test/**/*.js",
+    "test": "aegir test -f ./dist/test/*.js -f ./dist/test/**/*.js",
     "test:node": "npm run test -- -t node --cov",
     "test:electron-main": "npm run test -- -t electron-main",
     "release": "semantic-release"
   },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/libp2p/js-libp2p-tcp.git"
-  },
-  "keywords": [
-    "libp2p",
-    "network",
-    "p2p",
-    "peer",
-    "peer-to-peer",
-    "IPFS",
-    "TCP"
-  ],
-  "license": "(Apache-2.0 OR MIT)",
-  "bugs": {
-    "url": "https://github.com/libp2p/js-libp2p-tcp/issues"
-  },
-  "homepage": "https://github.com/libp2p/js-libp2p-tcp",
-  "engines": {
-    "node": ">=14.0.0"
-  },
-  "types": "dist/src/index.d.ts",
-  "devDependencies": {
-    "@libp2p/interface-compliance-tests": "^1.0.1",
-    "@libp2p/interfaces": "^1.0.0",
-    "@types/debug": "^4.1.5",
-    "@types/mocha": "^9.0.0",
-    "aegir": "^36.1.3",
-    "it-pipe": "^1.1.0",
-    "sinon": "^12.0.0",
-    "streaming-iterables": "^6.0.0"
-  },
   "dependencies": {
-    "@libp2p/utils": "^1.0.1",
+    "@libp2p/logger": "^1.0.2",
+    "@libp2p/utils": "^1.0.6",
     "@multiformats/mafmt": "^11.0.0",
     "@multiformats/multiaddr": "^10.1.1",
-    "abortable-iterator": "^3.0.1",
-    "debug": "^4.3.1",
+    "abortable-iterator": "^4.0.2",
     "err-code": "^3.0.1",
     "stream-to-it": "^0.2.2"
   },
-  "contributors": [
-    "David Dias <daviddias.p@gmail.com>",
-    "Jacob Heun <jacobheun@gmail.com>",
-    "Vasco Santos <vasco.santos@moxy.studio>",
-    "Stephen Whitmore <stephen.whitmore@gmail.com>",
-    "Friedel Ziegelmayer <dignifiedquire@gmail.com>",
-    "Alex Potsides <alex@achingbrain.net>",
-    "Richard Littauer <richard.littauer@gmail.com>",
-    "Tom White <tomtinkerer@gmail.com>",
-    "Alan Shaw <alan@tableflip.io>",
-    "Nazar Hussain <nazarhussain@gmail.com>",
-    "Pedro Teixeira <i@pgte.me>",
-    "Prashanth Chandra <coolshanth94@gmail.com>",
-    "Ryan Mehta <ryan.mehta@gmail.com>",
-    "Linus Unnebäck <linus@folkdatorn.se>",
-    "Cayman <caymannava@gmail.com>",
-    "Diogo Silva <fsdiogo@gmail.com>",
-    "Dmitriy Ryajov <dryajov@gmail.com>",
-    "Drew Stone <drewstone329@gmail.com>",
-    "Evan Schwartz <evan.mark.schwartz@gmail.com>",
-    "João Antunes <j.goncalo.antunes@gmail.com>",
-    "Mikeal Rogers <mikeal.rogers@gmail.com>"
-  ]
+  "devDependencies": {
+    "@libp2p/interface-compliance-tests": "^1.1.2",
+    "@libp2p/interfaces": "^1.3.2",
+    "aegir": "^36.1.3",
+    "it-pipe": "^2.0.3",
+    "sinon": "^13.0.0",
+    "streaming-iterables": "^6.0.0",
+    "uint8arrays": "^3.0.0"
+  }
 }

package/src/index.ts

@@ -1,18 +1,17 @@
 import net from 'net'
 import * as mafmt from '@multiformats/mafmt'
 import errCode from 'err-code'
-import debug from 'debug'
-import { toConnection } from './socket-to-conn.js'
+import { logger } from '@libp2p/logger'
+import { toMultiaddrConnection } from './socket-to-conn.js'
 import { createListener } from './listener.js'
 import { multiaddrToNetConfig } from './utils.js'
 import { AbortError } from 'abortable-iterator'
 import { CODE_CIRCUIT, CODE_P2P } from './constants.js'
-import type { Transport, Upgrader } from '@libp2p/interfaces/transport'
-import type { Connection } from '@libp2p/interfaces/connection'
+import type { Transport, Upgrader, ListenerOptions, Listener } from '@libp2p/interfaces/transport'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { Socket } from 'net'
 
-const log = debug('libp2p:tcp')
+const log = logger('libp2p:tcp')
 
 /**
  * @typedef {import('multiaddr').Multiaddr} Multiaddr
@@ -30,7 +29,7 @@ interface DialOptions {
   signal?: AbortSignal
 }
 
-export class TCP implements Transport<DialOptions, {}> {
+export class TCP implements Transport<DialOptions, ListenerOptions> {
   private readonly _upgrader: Upgrader
 
   constructor (options: TCPOptions) {
@@ -51,7 +50,7 @@ export class TCP implements Transport<DialOptions, {}> {
       log('socket error', err)
     })
 
-    const maConn = toConnection(socket, { remoteAddr: ma, signal: options.signal })
+    const maConn = toMultiaddrConnection(socket, { remoteAddr: ma, signal: options.signal })
     log('new outbound connection %s', maConn.remoteAddr)
     const conn = await this._upgrader.upgradeOutbound(maConn)
     log('outbound connection %s upgraded', maConn.remoteAddr)
@@ -126,8 +125,8 @@ export class TCP implements Transport<DialOptions, {}> {
    * anytime a new incoming Connection has been successfully upgraded via
    * `upgrader.upgradeInbound`.
    */
-  createListener (options: {}, handler?: (connection: Connection) => void) {
-    return createListener({ handler: handler, upgrader: this._upgrader })
+  createListener (options: ListenerOptions = {}): Listener {
+    return createListener({ upgrader: this._upgrader, ...options })
   }
 
   /**

package/src/listener.ts

@@ -1,24 +1,18 @@
 import net from 'net'
-import { EventEmitter } from 'events'
-import debug from 'debug'
-import { toConnection } from './socket-to-conn.js'
+import { logger } from '@libp2p/logger'
+import { toMultiaddrConnection } from './socket-to-conn.js'
 import { CODE_P2P } from './constants.js'
 import {
   getMultiaddrs,
   multiaddrToNetConfig
 } from './utils.js'
+import { EventEmitter, CustomEvent } from '@libp2p/interfaces'
 import type { Connection } from '@libp2p/interfaces/connection'
-import type { MultiaddrConnection, Upgrader, Listener } from '@libp2p/interfaces/transport'
+import type { MultiaddrConnection, Upgrader, Listener, ListenerEvents, ConnectionHandler } from '@libp2p/interfaces/transport'
 import type { Server } from 'net'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
-const log = Object.assign(
-  debug('libp2p:tcp:listener'),
-  { error: debug('libp2p:tcp:listener:error') })
-
-interface ServerWithMultiaddrConnections extends Server {
-  __connections: MultiaddrConnection[]
-}
+const log = logger('libp2p:tcp:listener')
 
 /**
  * Attempts to close the given maConn. If a failure occurs, it will be logged
@@ -36,137 +30,159 @@ interface Context {
   upgrader: Upgrader
 }
 
-/**
- * Create listener
- */
-export function createListener (context: Context) {
-  const {
-    handler, upgrader
-  } = context
+class TCPListener extends EventEmitter<ListenerEvents> implements Listener {
+  private peerId?: string
+  private listeningAddr?: Multiaddr
+  private readonly server: Server
+  private connections: MultiaddrConnection[]
+
+  constructor (upgrader: Upgrader, handler?: ConnectionHandler) {
+    super()
+
+    this.connections = []
+
+    this.server = net.createServer(socket => {
+      // Avoid uncaught errors caused by unstable connections
+      socket.on('error', err => {
+        log('socket error', err)
+      })
 
-  let peerId: string | null
-  let listeningAddr: Multiaddr
+      let maConn: MultiaddrConnection
+      try {
+        maConn = toMultiaddrConnection(socket, { listeningAddr: this.listeningAddr })
+      } catch (err) {
+        log.error('inbound connection failed', err)
+        return
+      }
 
-  const server: ServerWithMultiaddrConnections = Object.assign(net.createServer(socket => {
-    // Avoid uncaught errors caused by unstable connections
-    socket.on('error', err => {
-      log('socket error', err)
+      log('new inbound connection %s', maConn.remoteAddr)
+      try {
+        upgrader.upgradeInbound(maConn)
+          .then((conn) => {
+            log('inbound connection %s upgraded', maConn.remoteAddr)
+
+            this.trackConn(maConn, socket)
+
+            if (handler != null) {
+              handler(conn)
+            }
+
+            this.dispatchEvent(new CustomEvent('connection', {
+              detail: conn
+            }))
+          })
+          .catch(async err => {
+            log.error('inbound connection failed', err)
+
+            await attemptClose(maConn)
+          })
+          .catch(err => {
+            log.error('closing inbound connection failed', err)
+          })
+      } catch (err) {
+        log.error('inbound connection failed', err)
+
+        attemptClose(maConn)
+          .catch(err => {
+            log.error('closing inbound connection failed', err)
+          })
+      }
+    })
+    this.server.on('error', err => {
+      this.dispatchEvent(new CustomEvent('error', {
+        detail: err
+      }))
     })
+    this.server.on('close', () => {
+      this.dispatchEvent(new CustomEvent('close'))
+    })
+    this.server.on('listening', () => {
+      this.dispatchEvent(new CustomEvent('listening'))
+    })
+  }
 
-    let maConn: MultiaddrConnection
-    try {
-      maConn = toConnection(socket, { listeningAddr })
-    } catch (err) {
-      log.error('inbound connection failed', err)
-      return
+  getAddrs () {
+    let addrs: Multiaddr[] = []
+    const address = this.server.address()
+
+    if (address == null) {
+      throw new Error('Listener is not ready yet')
     }
 
-    log('new inbound connection %s', maConn.remoteAddr)
-    try {
-      upgrader.upgradeInbound(maConn)
-        .then((conn) => {
-          log('inbound connection %s upgraded', maConn.remoteAddr)
-
-          trackConn(server, maConn)
-
-          if (handler != null) {
-            handler(conn)
-          }
-
-          listener.emit('connection', conn)
-        })
-        .catch(async err => {
-          log.error('inbound connection failed', err)
-
-          await attemptClose(maConn)
-        })
-        .catch(err => {
-          log.error('closing inbound connection failed', err)
-        })
-    } catch (err) {
-      log.error('inbound connection failed', err)
-
-      attemptClose(maConn)
-        .catch(err => {
-          log.error('closing inbound connection failed', err)
-        })
+    if (typeof address === 'string') {
+      throw new Error('Incorrect server address type')
     }
-  }),
-  // Keep track of open connections to destroy in case of timeout
-  { __connections: [] })
 
-  const listener: Listener = Object.assign(new EventEmitter(), {
-    getAddrs: () => {
-      let addrs: Multiaddr[] = []
-      const address = server.address()
+    if (this.listeningAddr == null) {
+      throw new Error('Listener is not ready yet')
+    }
 
-      if (address == null) {
-        throw new Error('Listener is not ready yet')
-      }
+    // Because TCP will only return the IPv6 version
+    // we need to capture from the passed multiaddr
+    if (this.listeningAddr.toString().startsWith('/ip4')) {
+      addrs = addrs.concat(getMultiaddrs('ip4', address.address, address.port))
+    } else if (address.family === 'IPv6') {
+      addrs = addrs.concat(getMultiaddrs('ip6', address.address, address.port))
+    }
 
-      if (typeof address === 'string') {
-        throw new Error('Incorrect server address type')
-      }
+    return addrs.map(ma => this.peerId != null ? ma.encapsulate(`/p2p/${this.peerId}`) : ma)
+  }
 
-      // Because TCP will only return the IPv6 version
-      // we need to capture from the passed multiaddr
-      if (listeningAddr.toString().startsWith('/ip4')) {
-        addrs = addrs.concat(getMultiaddrs('ip4', address.address, address.port))
-      } else if (address.family === 'IPv6') {
-        addrs = addrs.concat(getMultiaddrs('ip6', address.address, address.port))
-      }
+  async listen (ma: Multiaddr) {
+    const peerId = ma.getPeerId()
 
-      return addrs.map(ma => peerId != null ? ma.encapsulate(`/p2p/${peerId}`) : ma)
-    },
-    listen: async (ma: Multiaddr) => {
-      listeningAddr = ma
-      peerId = ma.getPeerId()
+    if (peerId == null) {
+      ma = ma.decapsulateCode(CODE_P2P)
+    } else {
+      this.peerId = peerId
+    }
 
-      if (peerId == null) {
-        listeningAddr = ma.decapsulateCode(CODE_P2P)
-      }
+    this.listeningAddr = ma
 
-      return await new Promise<void>((resolve, reject) => {
-        const options = multiaddrToNetConfig(listeningAddr)
-        server.listen(options, (err?: any) => {
-          if (err != null) {
-            return reject(err)
-          }
-          log('Listening on %s', server.address())
-          resolve()
-        })
+    return await new Promise<void>((resolve, reject) => {
+      const options = multiaddrToNetConfig(ma)
+      this.server.listen(options, (err?: any) => {
+        if (err != null) {
+          return reject(err)
+        }
+        log('Listening on %s', this.server.address())
+        resolve()
       })
-    },
-    close: async () => {
-      if (!server.listening) {
-        return
-      }
-
-      await Promise.all([
-        server.__connections.map(async maConn => await attemptClose(maConn))
-      ])
+    })
+  }
 
-      await new Promise<void>((resolve, reject) => {
-        server.close(err => (err != null) ? reject(err) : resolve())
-      })
+  async close () {
+    if (!this.server.listening) {
+      return
     }
-  })
 
-  server
-    .on('listening', () => listener.emit('listening'))
-    .on('error', err => listener.emit('error', err))
-    .on('close', () => listener.emit('close'))
+    await Promise.all([
+      this.connections.map(async maConn => await attemptClose(maConn))
+    ])
 
-  return listener
-}
+    await new Promise<void>((resolve, reject) => {
+      this.server.close(err => (err != null) ? reject(err) : resolve())
+    })
+  }
+
+  trackConn (maConn: MultiaddrConnection, socket: net.Socket) {
+    this.connections.push(maConn)
 
-function trackConn (server: ServerWithMultiaddrConnections, maConn: MultiaddrConnection) {
-  server.__connections.push(maConn)
+    const untrackConn = () => {
+      this.connections = this.connections.filter(c => c !== maConn)
+    }
 
-  const untrackConn = () => {
-    server.__connections = server.__connections.filter(c => c !== maConn)
+    socket.once('close', untrackConn)
   }
+}
+
+/**
+ * Create listener
+ */
+export function createListener (context: Context) {
+  const {
+    handler, upgrader
+  } = context
 
-  // @ts-expect-error
-  maConn.conn.once('close', untrackConn)
+  return new TCPListener(upgrader, handler)
 }

package/src/socket-to-conn.ts

@@ -1,5 +1,5 @@
-import abortable from 'abortable-iterator'
-import debug from 'debug'
+import { abortableSource } from 'abortable-iterator'
+import { logger } from '@libp2p/logger'
 // @ts-expect-error no types
 import toIterable from 'stream-to-it'
 import { ipPortToMultiaddr as toMultiaddr } from '@libp2p/utils/ip-port-to-multiaddr'
@@ -8,7 +8,7 @@ import type { Socket } from 'net'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { MultiaddrConnection } from '@libp2p/interfaces/transport'
 
-const log = debug('libp2p:tcp:socket')
+const log = logger('libp2p:tcp:socket')
 
 interface ToConnectionOptions {
   listeningAddr?: Multiaddr
@@ -21,7 +21,7 @@ interface ToConnectionOptions {
  * Convert a socket into a MultiaddrConnection
  * https://github.com/libp2p/interface-transport#multiaddrconnection
  */
-export const toConnection = (socket: Socket, options?: ToConnectionOptions) => {
+export const toMultiaddrConnection = (socket: Socket, options?: ToConnectionOptions) => {
   options = options ?? {}
 
   // Check if we are connected on a unix path
@@ -38,7 +38,7 @@ export const toConnection = (socket: Socket, options?: ToConnectionOptions) => {
   const maConn: MultiaddrConnection = {
     async sink (source) {
       if ((options?.signal) != null) {
-        source = abortable(source, options.signal)
+        source = abortableSource(source, options.signal)
       }
 
       try {
@@ -61,11 +61,7 @@ export const toConnection = (socket: Socket, options?: ToConnectionOptions) => {
     },
 
     // Missing Type for "abortable"
-    source: (options.signal != null) ? abortable(source, options.signal) : source,
-
-    conn: socket,
-
-    localAddr: options.localAddr ?? toMultiaddr(socket.localAddress ?? '', socket.localPort ?? ''),
+    source: (options.signal != null) ? abortableSource(source, options.signal) : source,
 
     // If the remote address was passed, use it - it may have the peer ID encapsulated
     remoteAddr: options.remoteAddr ?? toMultiaddr(socket.remoteAddress ?? '', socket.remotePort ?? ''),

package/.aegir.cjs

@@ -1,8 +0,0 @@
-module.exports = {
-  build: {
-    config: {
-      platform: 'node'
-    },
-    bundlesizeMax: '44KB'
-  }
-}