Consistent Hashing for WebSockets: Sticky Gateways During Scale Events

// ws/hash-ring.ts
import { createHash } from "node:crypto";

export class HashRing {
 private ring: { hash: number; node: string }[] = [];
 constructor(nodes: string[], vnode = 64) {
 for (const n of nodes) {
 for (let i = 0; i < vnode; i++) {
 const hash = this.h(`${n}#${i}`);
 this.ring.push({ hash, node: n });
 }
 }
 this.ring.sort((a, b) => a.hash - b.hash);
 }
 private h(s: string) {
 return createHash("sha256").update(s).digest().readUInt32BE(0);
 }
 owner(key: string): string {
 const x = this.h(key);
 const i = this.ring.findIndex((e) => e.hash >= x);
 return (this.ring[i] ?? this.ring[0]).node; // ✅ wrap
 }
}

// ws/registry.ts
export async function bindConnection(connId: string, gatewayId: string) {
 await redis.set(`ws:${connId}`, gatewayId, "EX", 3600);
}

export async function publishToUser(userId: string, payload: unknown) {
 const conns = await redis.smembers(`user:${userId}:conns`);
 await Promise.all(
 conns.map(async (connId) => {
 const gw = await redis.get(`ws:${connId}`);
 if (!gw) return;
 // ✅ Direct to owning gateway; no broadcast storm
 await bus.send(gw, { connId, payload });
 })
 );
}

// ws/drain.ts
export async function drainGateway(gw: string, ring: HashRing) {
 const local = listLocalConnections();
 for (const c of local) {
 if (ring.owner(c.userId) === gw) continue; // still ours
 // Soft close — client reconnects with jitter into new owner
 c.socket.close(4001, "migrate");
 await sleep(5 + Math.random() * 50);
 }
 await deregisterFromRing(gw);
}

// client reconnect (browser / RN)
function backoff(attempt: number) {
 const base = Math.min(1000 * 2 ** attempt, 15000);
 return base * (0.5 + Math.random()); // ✅ avoid reconnect storms
}