@libp2p/tcp - npm Package Compare versions

Comparing version 7.0.3-ab0e3980 to 7.0.3-b1024c6c

dist/src/constants.d.ts

 export declare const CODE_P2P = 421;
 export declare const CODE_CIRCUIT = 290;
 export declare const CODE_UNIX = 400;
-export declare const CLOSE_TIMEOUT = 2000;
+export declare const CLOSE_TIMEOUT = 500;
 export declare const SOCKET_TIMEOUT: number;
 //# sourceMappingURL=constants.d.ts.map

dist/src/constants.js

@@ -6,5 +6,5 @@ // p2p multi-address code
 // Time to wait for a connection to close gracefully before destroying it manually
-export const CLOSE_TIMEOUT = 2000;
+export const CLOSE_TIMEOUT = 500;
 // Close the socket if there is no activity after this long in ms
 export const SOCKET_TIMEOUT = 5 * 60000; // 5 mins
 //# sourceMappingURL=constants.js.map

dist/src/index.d.ts

@@ -1,4 +0,4 @@
-import { type CreateListenerOptions, type DialOptions, type Transport } from '@libp2p/interface-transport';
+import { type CreateListenerOptions, type DialOptions, type Transport } from '@libp2p/interface/transport';
 import { type CloseServerOnMaxConnectionsOpts } from './listener.js';
-import type { CounterGroup, Metrics } from '@libp2p/interface-metrics';
+import type { CounterGroup, Metrics } from '@libp2p/interface/metrics';
 import type { AbortOptions } from '@multiformats/multiaddr';
@@ -5,0 +5,0 @@ export interface TCPOptions {

dist/src/index.js

 import net from 'net';
-import { symbol } from '@libp2p/interface-transport';
-import { AbortError, CodeError } from '@libp2p/interfaces/errors';
+import { AbortError, CodeError } from '@libp2p/interface/errors';
+import { symbol } from '@libp2p/interface/transport';
 import { logger } from '@libp2p/logger';
@@ -5,0 +5,0 @@ import * as mafmt from '@multiformats/mafmt';

dist/src/listener.d.ts

@@ -1,6 +0,6 @@
-import { EventEmitter } from '@libp2p/interfaces/events';
+import { EventEmitter } from '@libp2p/interface/events';
 import type { TCPCreateListenerOptions } from './index.js';
-import type { Connection } from '@libp2p/interface-connection';
-import type { CounterGroup, MetricGroup, Metrics } from '@libp2p/interface-metrics';
-import type { Upgrader, Listener, ListenerEvents } from '@libp2p/interface-transport';
+import type { 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 { Multiaddr } from '@multiformats/multiaddr';
@@ -7,0 +7,0 @@ export interface CloseServerOnMaxConnectionsOpts {

dist/src/listener.js

 import net from 'net';
-import { EventEmitter, CustomEvent } from '@libp2p/interfaces/events';
+import { EventEmitter, CustomEvent } from '@libp2p/interface/events';
 import { logger } from '@libp2p/logger';
@@ -4,0 +4,0 @@ import { CODE_P2P } from './constants.js';

dist/src/socket-to-conn.d.ts

@@ -1,3 +0,3 @@
-import type { MultiaddrConnection } from '@libp2p/interface-connection';
-import type { CounterGroup } from '@libp2p/interface-metrics';
+import type { MultiaddrConnection } from '@libp2p/interface/connection';
+import type { CounterGroup } from '@libp2p/interface/metrics';
 import type { Multiaddr } from '@multiformats/multiaddr';
@@ -4,0 +4,0 @@ import type { Socket } from 'net';

dist/src/socket-to-conn.js

@@ -1,2 +0,2 @@
-import { CodeError } from '@libp2p/interfaces/errors';
+import { CodeError } from '@libp2p/interface/errors';
 import { logger } from '@libp2p/logger';
@@ -91,3 +91,3 @@ import { ipPortToMultiaddr as toMultiaddr } from '@libp2p/utils/ip-port-to-multiaddr';
         timeline: { open: Date.now() },
-        async close() {
+        async close(options = {}) {
             if (socket.destroyed) {
@@ -97,57 +97,44 @@ log('%s socket was already destroyed when trying to close', lOptsStr);
             }
-            log('%s closing socket', lOptsStr);
-            await new Promise((resolve, reject) => {
-                const start = Date.now();
-                let timeout;
-                socket.once('close', () => {
-                    log('%s socket closed', lOptsStr);
-                    // socket completely closed
-                    if (timeout !== undefined) {
-                        clearTimeout(timeout);
+            options.signal = options.signal ?? AbortSignal.timeout(closeTimeout);
+            try {
+                log('%s closing socket', lOptsStr);
+                await new Promise((resolve, reject) => {
+                    socket.once('close', () => {
+                        // socket completely closed
+                        log('%s socket closed', lOptsStr);
+                        resolve();
+                    });
+                    socket.once('error', (err) => {
+                        log('%s socket error', lOptsStr, err);
+                        // error closing socket
+                        if (maConn.timeline.close == null) {
+                            maConn.timeline.close = Date.now();
+                        }
+                        reject(err);
+                    });
+                    // 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 (maybe) before the timeout
+                            socket.destroy();
+                        });
                     }
-                    resolve();
-                });
-                socket.once('error', (err) => {
-                    log('%s socket error', lOptsStr, err);
-                    // error closing socket
-                    if (maConn.timeline.close == null) {
-                        maConn.timeline.close = Date.now();
+                    else {
+                        // nothing to send, destroy immediately, no need for the timeout
+                        socket.destroy();
                     }
-                    if (socket.destroyed) {
-                        if (timeout !== undefined) {
-                            clearTimeout(timeout);
-                        }
-                    }
-                    reject(err);
                 });
-                // shorten inactivity timeout
-                socket.setTimeout(closeTimeout);
-                // close writable end of the socket
-                socket.end();
-                if (socket.writableLength > 0) {
-                    // Attempt to end the socket. If it takes longer to close than the
-                    // timeout, destroy it manually.
-                    timeout = setTimeout(() => {
-                        if (socket.destroyed) {
-                            log('%s is already destroyed', lOptsStr);
-                            resolve();
-                        }
-                        else {
-                            log('%s socket close timeout after %dms, destroying it manually', lOptsStr, Date.now() - start);
-                            // will trigger 'error' and 'close' events that resolves promise
-                            socket.destroy(new CodeError('Socket close timeout', 'ERR_SOCKET_CLOSE_TIMEOUT'));
-                        }
-                    }, closeTimeout).unref();
-                    // 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 (maybe) before the timeout
-                        socket.destroy();
-                    });
-                }
-                else {
-                    // nothing to send, destroy immediately, no need the timeout
-                    socket.destroy();
-                }
-            });
+            }
+            catch (err) {
+                this.abort(err);
+            }
+        },
+        abort: (err) => {
+            log('%s socket abort due to error', lOptsStr, err);
+            socket.destroy(err);
         }
@@ -154,0 +141,0 @@ };

package.json

 {
   "name": "@libp2p/tcp",
-  "version": "7.0.3-ab0e3980",
+  "version": "7.0.3-b1024c6c",
   "description": "A TCP transport for libp2p",
@@ -53,8 +53,5 @@ "license": "Apache-2.0 OR MIT",
   "dependencies": {
-    "@libp2p/interface-connection": "5.1.1-ab0e3980",
-    "@libp2p/interface-metrics": "4.0.8-ab0e3980",
-    "@libp2p/interface-transport": "4.0.3-ab0e3980",
-    "@libp2p/interfaces": "3.3.2-ab0e3980",
-    "@libp2p/logger": "2.1.1-ab0e3980",
-    "@libp2p/utils": "3.0.12-ab0e3980",
+    "@libp2p/interface": "0.0.1-b1024c6c",
+    "@libp2p/logger": "2.1.1-b1024c6c",
+    "@libp2p/utils": "3.0.12-b1024c6c",
     "@multiformats/mafmt": "^12.1.2",
@@ -66,10 +63,9 @@ "@multiformats/multiaddr": "^12.1.3",
   "devDependencies": {
-    "@libp2p/interface-mocks": "12.0.1-ab0e3980",
-    "@libp2p/interface-transport-compliance-tests": "4.0.2-ab0e3980",
-    "aegir": "^39.0.10",
+    "@libp2p/interface-compliance-tests": "3.0.7-b1024c6c",
+    "aegir": "^39.0.13",
     "it-all": "^3.0.1",
     "it-pipe": "^3.0.1",
     "p-defer": "^4.0.0",
-    "sinon": "^15.1.0",
-    "uint8arrays": "^4.0.3"
+    "sinon": "^15.1.2",
+    "uint8arrays": "^4.0.4"
   },
@@ -76,0 +72,0 @@ "typedoc": {

src/constants.ts

@@ -7,5 +7,5 @@ // p2p multi-address code
 // Time to wait for a connection to close gracefully before destroying it manually
-export const CLOSE_TIMEOUT = 2000
+export const CLOSE_TIMEOUT = 500
 
 // Close the socket if there is no activity after this long in ms
 export const SOCKET_TIMEOUT = 5 * 60000 // 5 mins

src/index.ts

 import net from 'net'
-import { type CreateListenerOptions, type DialOptions, type Listener, symbol, type Transport } from '@libp2p/interface-transport'
-import { AbortError, CodeError } from '@libp2p/interfaces/errors'
+import { AbortError, CodeError } from '@libp2p/interface/errors'
+import { type CreateListenerOptions, type DialOptions, symbol, type Transport, type Listener } from '@libp2p/interface/transport'
 import { logger } from '@libp2p/logger'
@@ -10,4 +10,4 @@ import * as mafmt from '@multiformats/mafmt'
 import { multiaddrToNetConfig } from './utils.js'
-import type { Connection } from '@libp2p/interface-connection'
-import type { CounterGroup, Metrics } from '@libp2p/interface-metrics'
+import type { Connection } from '@libp2p/interface/connection'
+import type { CounterGroup, Metrics } from '@libp2p/interface/metrics'
 import type { AbortOptions, Multiaddr } from '@multiformats/multiaddr'
@@ -14,0 +14,0 @@ import type { Socket, IpcSocketConnectOpts, TcpSocketConnectOpts } from 'net'

src/listener.ts

 import net from 'net'
-import { EventEmitter, CustomEvent } from '@libp2p/interfaces/events'
+import { EventEmitter, CustomEvent } from '@libp2p/interface/events'
 import { logger } from '@libp2p/logger'
@@ -12,5 +12,5 @@ import { CODE_P2P } from './constants.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 { Upgrader, Listener, ListenerEvents } from '@libp2p/interface-transport'
+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 { Multiaddr } from '@multiformats/multiaddr'
@@ -17,0 +17,0 @@

src/socket-to-conn.ts

@@ -1,2 +0,2 @@
-import { CodeError } from '@libp2p/interfaces/errors'
+import { CodeError } from '@libp2p/interface/errors'
 import { logger } from '@libp2p/logger'
@@ -8,5 +8,5 @@ import { ipPortToMultiaddr as toMultiaddr } from '@libp2p/utils/ip-port-to-multiaddr'
 import { multiaddrToNetConfig } from './utils.js'
-import type { MultiaddrConnection } from '@libp2p/interface-connection'
-import type { CounterGroup } from '@libp2p/interface-metrics'
-import type { Multiaddr } from '@multiformats/multiaddr'
+import type { MultiaddrConnection } from '@libp2p/interface/connection'
+import type { CounterGroup } from '@libp2p/interface/metrics'
+import type { AbortOptions, Multiaddr } from '@multiformats/multiaddr'
 import type { Socket } from 'net'
@@ -124,3 +124,3 @@
 
-    async close () {
+    async close (options: AbortOptions = {}) {
       if (socket.destroyed) {
@@ -131,65 +131,51 @@ log('%s socket was already destroyed when trying to close', lOptsStr)
 
-      log('%s closing socket', lOptsStr)
-      await new Promise<void>((resolve, reject) => {
-        const start = Date.now()
+      options.signal = options.signal ?? AbortSignal.timeout(closeTimeout)
 
-        let timeout: NodeJS.Timeout | undefined
+      try {
+        log('%s closing socket', lOptsStr)
+        await new Promise<void>((resolve, reject) => {
+          socket.once('close', () => {
+            // socket completely closed
+            log('%s socket closed', lOptsStr)
+            resolve()
+          })
+          socket.once('error', (err: Error) => {
+            log('%s socket error', lOptsStr, err)
 
-        socket.once('close', () => {
-          log('%s socket closed', lOptsStr)
-          // socket completely closed
-          if (timeout !== undefined) {
-            clearTimeout(timeout)
-          }
-          resolve()
-        })
-        socket.once('error', (err: Error) => {
-          log('%s socket error', lOptsStr, err)
+            // error closing socket
+            if (maConn.timeline.close == null) {
+              maConn.timeline.close = Date.now()
+            }
 
-          // error closing socket
-          if (maConn.timeline.close == null) {
-            maConn.timeline.close = Date.now()
-          }
+            reject(err)
+          })
 
-          if (socket.destroyed) {
-            if (timeout !== undefined) {
-              clearTimeout(timeout)
-            }
-          }
+          // shorten inactivity timeout
+          socket.setTimeout(closeTimeout)
 
-          reject(err)
-        })
+          // close writable end of the socket
+          socket.end()
 
-        // shorten inactivity timeout
-        socket.setTimeout(closeTimeout)
+          if (socket.writableLength > 0) {
+            // there are outgoing bytes waiting to be sent
+            socket.once('drain', () => {
+              log('%s socket drained', lOptsStr)
 
-        // close writable end of the socket
-        socket.end()
+              // 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()
+          }
+        })
+      } catch (err: any) {
+        this.abort(err)
+      }
+    },
 
-        if (socket.writableLength > 0) {
-          // Attempt to end the socket. If it takes longer to close than the
-          // timeout, destroy it manually.
-          timeout = setTimeout(() => {
-            if (socket.destroyed) {
-              log('%s is already destroyed', lOptsStr)
-              resolve()
-            } else {
-              log('%s socket close timeout after %dms, destroying it manually', lOptsStr, Date.now() - start)
+    abort: (err: Error) => {
+      log('%s socket abort due to error', lOptsStr, err)
 
-              // will trigger 'error' and 'close' events that resolves promise
-              socket.destroy(new CodeError('Socket close timeout', 'ERR_SOCKET_CLOSE_TIMEOUT'))
-            }
-          }, closeTimeout).unref()
-          // 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 (maybe) before the timeout
-            socket.destroy()
-          })
-        } else {
-          // nothing to send, destroy immediately, no need the timeout
-          socket.destroy()
-        }
-      })
+      socket.destroy(err)
     }
@@ -196,0 +182,0 @@ }

No alert changes

Improved metrics

Total package byte prevSize

204617

increased by10.63%

Dependency count

7

decreased by-30%

Dev dependency count

7

decreased by-12.5%

Lines of code

1862

increased by3.1%

Dependency changes

• + Added@libp2p/interface@0.0.1-b1024c6c

• + Added@libp2p/interface@0.0.1-b1024c6c(transitive)

• + Added@libp2p/logger@2.1.1-b1024c6c(transitive)

• + Added@libp2p/utils@3.0.12-b1024c6c(transitive)

• + Addedmultiformats@12.1.313.3.2(transitive)

• - Removed@libp2p/interface-connection@5.1.1-ab0e3980

• - Removed@libp2p/interface-metrics@4.0.8-ab0e3980

• - Removed@libp2p/interface-transport@4.0.3-ab0e3980

• - Removed@libp2p/interfaces@3.3.2-ab0e3980

• - Removed@libp2p/interface-connection@5.1.1-ab0e3980(transitive)

• - Removed@libp2p/interface-metrics@4.0.8-ab0e3980(transitive)

• - Removed@libp2p/interface-peer-id@2.0.2-ab0e3980(transitive)

• - Removed@libp2p/interface-peer-store@2.0.4-ab0e3980(transitive)

• - Removed@libp2p/interface-stream-muxer@4.1.2-ab0e3980(transitive)

• - Removed@libp2p/interface-transport@4.0.3-ab0e3980(transitive)

• - Removed@libp2p/interfaces@3.3.2-ab0e3980(transitive)

• - Removed@libp2p/logger@2.1.1-ab0e3980(transitive)

• - Removed@libp2p/utils@3.0.12-ab0e3980(transitive)

• - Removedany-signal@4.1.1(transitive)

• - Removedmultiformats@11.0.213.3.1(transitive)

• Updated@libp2p/logger@2.1.1-b1024c6c

• Updated@libp2p/utils@3.0.12-b1024c6c