Speed up isLocalPortActive with caching & server reuse

This only covers localhost, but that's quite a common case for testing
scenarios. In practice this speeds up some proxying benchmarks about
30%.

Author: pimterry

karma.conf.js

@@ -32,7 +32,10 @@ module.exports = function(config) {
                     "dns2": require.resolve('./test/empty-stub.js'),
                     "ws": require.resolve('./test/empty-stub.js'),
                     "tmp-promise": require.resolve('./test/empty-stub.js'),
-                    "undici": require.resolve('./test/empty-stub.js')
+                    "undici": require.resolve('./test/empty-stub.js'),
+                    // socket-util has module-level Node-only code (net.createServer),
+                    // but is imported by some tests for isLocalIPv6Available:
+                    [require.resolve('./src/util/socket-util')]: require.resolve('./test/empty-stub.js')
                 },
                 fallback: {
                     // With Webpack 5, we need explicit mocks for all node modules. Because the

src/util/socket-util.ts

@@ -23,25 +23,64 @@ import {
 import { getSocketMetadataTags } from './socket-metadata';
 import { normalizeIP } from './ip-utils';
 
-// Test if a local port for a given interface (IPv4/6) is currently in use
+// Test if a local port for a given interface (IPv4/6) is currently in use, by attempting
+// to bind to it. We reuse a single server instance and cache results to avoid creating
+// a new server on every request. Concurrent checks for the same port share one probe.
+const probeServer = net.createServer();
+const portActiveCache = new Map<string, { result: boolean, expires: number }>();
+const portActiveInFlight = new Map<string, Promise<boolean>>();
+const PORT_ACTIVE_CACHE_TTL = 5000; // 5 seconds
+
 export async function isLocalPortActive(interfaceIp: '::1' | '127.0.0.1', port: number) {
     if (interfaceIp === '::1' && !isLocalIPv6Available) return false;
 
-    return new Promise((resolve) => {
-        const server = net.createServer();
-        server.listen({
-            host: interfaceIp,
-            port,
-            ipv6Only: interfaceIp === '::1'
-        });
-        server.once('listening', () => {
-            resolve(false);
-            server.close(() => {});
-        });
-        server.once('error', (e) => {
-            resolve(true);
+    const cacheKey = `${interfaceIp}:${port}`;
+
+    const cached = portActiveCache.get(cacheKey);
+    if (cached && cached.expires > Date.now()) {
+        return cached.result;
+    }
+
+    // Deduplicate concurrent checks for the same address:port
+    let probe = portActiveInFlight.get(cacheKey);
+    if (!probe) {
+        probe = probePort(interfaceIp, port);
+        portActiveInFlight.set(cacheKey, probe);
+        probe.then((result) => {
+            portActiveCache.set(cacheKey, { result, expires: Date.now() + PORT_ACTIVE_CACHE_TTL });
+            portActiveInFlight.delete(cacheKey);
         });
-    });
+    }
+
+    return probe;
+}
+
+// Serialized via the in-flight map above — only one probe runs at a time per key,
+// and different keys won't collide because they share the single probeServer sequentially
+// via the listen/close cycle.
+let probeServerReady = Promise.resolve();
+
+function probePort(interfaceIp: string, port: number): Promise<boolean> {
+    const result = probeServerReady.then(() =>
+        new Promise<boolean>((resolve) => {
+            probeServer.listen({
+                host: interfaceIp,
+                port,
+                ipv6Only: interfaceIp === '::1'
+            });
+            probeServer.once('listening', () => {
+                probeServer.close(() => resolve(false));
+            });
+            probeServer.once('error', () => {
+                resolve(true);
+            });
+        })
+    );
+
+    // Chain so the next probe waits for this one to fully complete
+    probeServerReady = result.then(() => {});
+
+    return result;
 }
 
 // This file imported in browsers etc as it's used in handlers, but none of these methods are used