// A datagram the document server cannot send to one peer is that peer's problem // alone. It never escapes a timer or the receive handler, never stops the server // serving the others, and only a datagram that can never be sent as built ends // the session that owes it. import assert from "node:assert/strict"; import { createSocket, type RemoteInfo, type Socket } from "node:dgram"; import test from "node:test"; import { documentPayloadFromBytes } from "@gamecult/cultcache-ts"; import { encodeWireValue } from "cultnet-ts/wire"; import { CultNetDocumentRegistry, CultNetRudpSession, decodeRudpPacket, encodeRudpPacket, type CultNetPeer, } from "cultnet-ts"; import { CultMesh } from "../src/index"; async function waitFor(predicate: () => boolean, description: string): Promise { const startedAt = Date.now(); while (!predicate()) { if (Date.now() - startedAt > 3_000) { throw new Error(`Timed out waiting for ${description}.`); } await new Promise((resolve) => setTimeout(resolve, 5)); } } const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms)); function watchUncaught(): { errors: unknown[]; stop: () => void } { const errors: unknown[] = []; const listener = (error: unknown) => errors.push(error); process.on("uncaughtException", listener); return { errors, stop: () => process.off("uncaughtException", listener) }; } function put(recordKey: string) { return { schemaVersion: "cultnet.document_put_raw.v0" as const, messageId: `put-${recordKey}`, document: { schemaId: "cultmesh.note.v0", recordKey, storedAt: new Date().toISOString(), payloadEncoding: "messagepack" as const, payload: documentPayloadFromBytes(encodeWireValue(recordKey)), }, }; } interface Server { socket: Socket; server: ReturnType; /** The record key of every put received, with the port it came from. */ puts: Map; closed: number[]; errors: Error[]; peer(name: string): Promise; } async function startServer(connectionId: number, socket: Socket): Promise { const puts = new Map(); const closed: number[] = []; const errors: Error[] = []; const server = CultMesh.createRudpDocumentServer("send-failure-server", connectionId, { documents: new CultNetDocumentRegistry(), socket, bindHost: "127.0.0.1", bindPort: 0, resendDelayMs: 10, resendPollMs: 10, sessionTimeoutMs: 1_000, onDocumentPutRaw: (document) => { puts.set(document.recordKey, document.remote.port); }, onSessionClosed: (session) => { closed.push(session.remote.port); }, onError: (error) => errors.push(error), }); await server.start(); const peer = (name: string) => CultMesh.createRudpPeer(name, connectionId, `rudp://127.0.0.1:${server.bind.port}`, { resendDelayMs: 10, resendPollMs: 5, connectTimeoutMs: 2_000, }); return { socket, server, puts, closed, errors, peer }; } test("a Connect whose Accept can never be sent starts no session, and the server keeps serving", async () => { const connectionId = 0x10203091; const uncaught = watchUncaught(); const socket = createSocket("udp4"); const served = await startServer(connectionId, socket); let peer: CultNetPeer | undefined; try { // A Connect as it arrives from UDP source port 0, which Node refuses to answer. const wire = Buffer.from(encodeRudpPacket(new CultNetRudpSession({ connectionId }).createConnect(Date.now()))); const remote: RemoteInfo = { address: "127.0.0.1", family: "IPv4", port: 0, size: wire.length }; socket.emit("message", wire, remote); // Past the idle timeout: a session that had started would have been closed by now. await sleep(1_300); peer = await served.peer("after-port-zero"); peer.send(put("after")); await waitFor(() => served.puts.has("after"), "the real peer's put"); assert.deepEqual(served.closed, [], "no session started for port 0"); assert.deepEqual(served.errors.map((error) => error.message), []); assert.deepEqual(uncaught.errors, []); } finally { uncaught.stop(); peer?.close(); served.server.close(); } }); test("a datagram that may yet pass is counted; one that never can ends only that peer's session", async () => { const connectionId = 0x10203092; const socket = createSocket("udp4"); // Sends to a failing port report the failure the way Node reports a system one: // later, through the send's callback. const failing = new Map(); const send = socket.send.bind(socket) as (...args: unknown[]) => void; Object.assign(socket, { send: (message: Uint8Array, port: number, address: string, callback?: (error: Error | null) => void) => { const code = failing.get(port); if (code === undefined) { send(message, port, address, callback); return; } process.nextTick(() => callback?.(Object.assign(new Error(`send failed: ${code}`), { code }))); }, }); const served = await startServer(connectionId, socket); let x: CultNetPeer | undefined; let y: CultNetPeer | undefined; try { x = await served.peer("x"); y = await served.peer("y"); x.send(put("x-1")); await waitFor(() => served.puts.has("x-1"), "X's first put"); const xPort = served.puts.get("x-1")!; // No route: X's acknowledgements are lost datagrams, counted, never reported as errors, // and end nothing. assert.equal(served.server.sendFailures, 0); failing.set(xPort, "EHOSTUNREACH"); x.send(put("x-2")); await waitFor(() => served.server.sendFailures >= 2, "the counted losses"); y.send(put("y-1")); await waitFor(() => served.puts.has("y-1"), "Y's put"); assert.deepEqual(served.closed, [], "a loss that may pass ends no session"); assert.deepEqual(served.errors.map((error) => error.message), [], "a lost datagram is not an error"); // X's retransmitted put is acknowledged again, and that datagram can never be sent. failing.set(xPort, "EMSGSIZE"); await waitFor(() => served.closed.length > 0, "X's session to end"); assert.deepEqual(served.closed, [xPort]); assert.equal( served.errors.some((error) => (error as NodeJS.ErrnoException).code === "EMSGSIZE"), false, "a datagram that can never be sent ends the session instead of being reported", ); y.send(put("y-2")); await waitFor(() => served.puts.has("y-2"), "Y's put after X ended"); assert.deepEqual(served.closed, [xPort]); } finally { x?.close(); y?.close(); served.server.close(); } }); test("a packet the session refuses ends only that peer's session, and the peer is told", async () => { const connectionId = 0x10203093; const socket = createSocket("udp4"); const served = await startServer(connectionId, socket); const raw = createSocket("udp4"); await new Promise((resolve) => raw.bind(0, "127.0.0.1", resolve)); const arrived: ReturnType[] = []; raw.on("message", (wire) => arrived.push(decodeRudpPacket(wire))); let y: CultNetPeer | undefined; try { const session = new CultNetRudpSession({ connectionId }); raw.send(encodeRudpPacket(session.createConnect(Date.now())), served.server.bind.port, "127.0.0.1"); await waitFor(() => arrived.some((packet) => packet.packetType === "accept"), "the Accept"); session.receive(arrived.find((packet) => packet.packetType === "accept")!, Date.now()); y = await served.peer("y"); // A reliable fragment whose metadata the session refuses: fragment id 0 names no set. // The session records its sequence before it refuses it. const [fragment] = session.sendMany("schema", new Uint8Array([1]), { reliable: true, ordered: true }); raw.send( encodeRudpPacket({ ...fragment!, fragmentId: 0, fragmentIndex: 0, fragmentCount: 2 }), served.server.bind.port, "127.0.0.1", ); await waitFor(() => arrived.some((packet) => packet.packetType === "disconnect"), "the goodbye"); const goodbye = arrived.find((packet) => packet.packetType === "disconnect")!; assert.equal(Buffer.from(goodbye.payload ?? []).toString("utf8"), "session refused a packet"); // The goodbye's ack field does not acknowledge the refused frame, or the peer would // count as delivered a frame that was never handled. const acknowledged = goodbye.ack === fragment!.sequence || (goodbye.ack > fragment!.sequence && goodbye.ack - fragment!.sequence <= 32 && (goodbye.ackMask & (1 << (goodbye.ack - fragment!.sequence - 1))) !== 0); assert.equal(acknowledged, false, "the goodbye acknowledged the refused frame"); assert.deepEqual(served.closed, [(raw.address() as { port: number }).port]); y.send(put("y-after")); await waitFor(() => served.puts.has("y-after"), "Y's put"); assert.deepEqual(served.errors.map((error) => error.message), []); } finally { y?.close(); raw.close(); served.server.close(); } });