@synnaxlabs/client 0.57.2 → 0.57.3

package/src/testutil/proxy.ts

@@ -35,12 +35,27 @@ export interface SeverableProxy {
   port: number;
   /** Drops every live connection and refuses new ones, as if the cluster died. */
   sever: () => Promise<void>;
+  /**
+   * Silently kills every live WebSocket connection, modeling a half-open socket (NAT
+   * timeout, VPN drop, laptop sleep): the cluster side is destroyed while the client
+   * side is held open with its writes discarded, so no close or reset ever reaches the
+   * client. New connections still forward. Returns how many connections were
+   * blackholed.
+   */
+  blackholeStreams: () => number;
   /** Accepts connections again on the same port. */
   restore: () => Promise<void>;
   /** Shuts the proxy down for good. */
   close: () => Promise<void>;
 }
 
+interface ProxiedPair {
+  downstream: Socket;
+  upstream: Socket;
+  /** Whether a WebSocket upgrade was observed on this connection. */
+  ws: boolean;
+}
+
 /**
  * Creates a TCP proxy in front of the live test cluster so specs can simulate
  * cluster downtime without touching the cluster itself. Connect a client to
@@ -50,7 +65,10 @@ export const createSeverableProxy = async (
   target: SeverableProxyTarget = {},
 ): Promise<SeverableProxy> => {
   const { host, port } = { ...DEFAULT_TARGET, ...target };
-  const sockets = new Set<Socket>();
+  const pairs = new Set<ProxiedPair>();
+  // Client-side sockets of blackholed connections: held open, silent, until the proxy
+  // is severed or closed.
+  const zombies = new Set<Socket>();
   let severed = false;
   const server = createServer((downstream) => {
     // A connection the kernel accepted before the sever is still delivered after it,
@@ -60,10 +78,16 @@ export const createSeverableProxy = async (
       return;
     }
     const upstream = connect(port, host);
-    sockets.add(downstream).add(upstream);
+    const pair: ProxiedPair = { downstream, upstream, ws: false };
+    pairs.add(pair);
+    // The upgrade can arrive on any request of a pooled keep-alive connection, not just
+    // the first, so every chunk is sniffed until one is seen.
+    downstream.on("data", (chunk: Buffer) => {
+      if (!pair.ws && /upgrade:\s*websocket/i.test(chunk.toString("latin1")))
+        pair.ws = true;
+    });
     const destroy = (): void => {
-      sockets.delete(downstream);
-      sockets.delete(upstream);
+      pairs.delete(pair);
       downstream.destroy();
       upstream.destroy();
     };
@@ -90,13 +114,42 @@ export const createSeverableProxy = async (
   const sever = async (): Promise<void> => {
     severed = true;
     const closed = new Promise<void>((resolve) => server.close(() => resolve()));
-    sockets.forEach((socket) => socket.destroy());
-    sockets.clear();
+    pairs.forEach(({ downstream, upstream }) => {
+      downstream.destroy();
+      upstream.destroy();
+    });
+    pairs.clear();
+    zombies.forEach((socket) => socket.destroy());
+    zombies.clear();
     await closed;
   };
+  const blackholeStreams = (): number => {
+    let count = 0;
+    for (const pair of [...pairs]) {
+      if (!pair.ws) continue;
+      count += 1;
+      const { downstream, upstream } = pair;
+      downstream.unpipe(upstream);
+      upstream.unpipe(downstream);
+      for (const socket of [downstream, upstream]) {
+        socket.removeAllListeners("close");
+        socket.removeAllListeners("error");
+        socket.on("error", () => {});
+      }
+      // Discard anything the client still writes so backpressure cannot close the
+      // socket on the proxy's behalf.
+      downstream.on("data", () => {});
+      downstream.resume();
+      upstream.destroy();
+      pairs.delete(pair);
+      zombies.add(downstream);
+    }
+    return count;
+  };
   return {
     port: boundPort,
     sever,
+    blackholeStreams,
     restore: async () => {
       severed = false;
       await listen(boundPort);