Apply PR feedback

Author: dapplion

src/index.ts

@@ -3,7 +3,7 @@ import * as mafmt from '@multiformats/mafmt'
 import errCode from 'err-code'
 import { logger } from '@libp2p/logger'
 import { toMultiaddrConnection } from './socket-to-conn.js'
-import { LimitServerConnectionsOpts, TCPListener } from './listener.js'
+import { CloseServerOnMaxConnectionsOpts, TCPListener } from './listener.js'
 import { multiaddrToNetConfig } from './utils.js'
 import { AbortError } from '@libp2p/interfaces/errors'
 import { CODE_CIRCUIT, CODE_P2P, CODE_UNIX } from './constants.js'
@@ -41,7 +41,7 @@ export interface TCPOptions {
    * Close server (stop listening for new connections) if connections exceed a limit.
    * Open server (start listening for new connections) if connections fall below a limit.
    */
-  limitServerConnections?: LimitServerConnectionsOpts
+  closeServerOnMaxConnections?: CloseServerOnMaxConnectionsOpts
 }
 
 /**
@@ -197,7 +197,7 @@ class TCP implements Transport {
     return new TCPListener({
       ...options,
       maxConnections: this.opts.maxConnections,
-      limitServerConnections: this.opts.limitServerConnections,
+      closeServerOnMaxConnections: this.opts.closeServerOnMaxConnections,
       socketInactivityTimeout: this.opts.inboundSocketInactivityTimeout,
       socketCloseTimeout: this.opts.socketCloseTimeout,
       metrics: this.components.metrics

src/listener.ts

@@ -27,9 +27,11 @@ async function attemptClose (maConn: MultiaddrConnection) {
   }
 }
 
-export interface LimitServerConnectionsOpts {
-  acceptBelow: number
-  rejectAbove: number
+export interface CloseServerOnMaxConnectionsOpts {
+  /** Server listens once connection count is less than `listenBelow` */
+  listenBelow: number
+  /** Close server once connection count is greater than or equal to `closeAbove` */
+  closeAbove: number
   onListenError?: (err: Error) => void
 }
 
@@ -40,7 +42,7 @@ interface Context extends TCPCreateListenerOptions {
   socketCloseTimeout?: number
   maxConnections?: number
   metrics?: Metrics
-  limitServerConnections?: LimitServerConnectionsOpts
+  closeServerOnMaxConnections?: CloseServerOnMaxConnectionsOpts
 }
 
 const SERVER_STATUS_UP = 1
@@ -82,6 +84,13 @@ export class TCPListener extends EventEmitter<ListenerEvents> implements Listene
       this.server.maxConnections = context.maxConnections
     }
 
+    if (context.closeServerOnMaxConnections != null) {
+      // Sanity check options
+      if (context.closeServerOnMaxConnections.closeAbove < context.closeServerOnMaxConnections.listenBelow) {
+        throw Error('closeAbove must be >= listenBelow')
+      }
+    }
+
     this.server
       .on('listening', () => {
         if (context.metrics != null) {
@@ -174,16 +183,16 @@ export class TCPListener extends EventEmitter<ListenerEvents> implements Listene
             this.connections.delete(maConn)
 
             if (
-              this.context.limitServerConnections != null &&
-              this.connections.size < this.context.limitServerConnections.acceptBelow
+              this.context.closeServerOnMaxConnections != null &&
+              this.connections.size < this.context.closeServerOnMaxConnections.listenBelow
             ) {
               // The most likely case of error is if the port taken by this application is binded by
               // another process during the time the server if closed. In that case there's not much
               // we can do. netListen() 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.netListen().catch(e => {
                 log.error('error attempting to listen server once connection count under limit', e)
-                this.context.limitServerConnections?.onListenError?.(e as Error)
+                this.context.closeServerOnMaxConnections?.onListenError?.(e as Error)
               })
             }
           })
@@ -193,8 +202,8 @@ export class TCPListener extends EventEmitter<ListenerEvents> implements Listene
           }
 
           if (
-            this.context.limitServerConnections != null &&
-            this.connections.size >= this.context.limitServerConnections.rejectAbove
+            this.context.closeServerOnMaxConnections != null &&
+            this.connections.size >= this.context.closeServerOnMaxConnections.closeAbove
           ) {
             this.netClose()
           }