@serverkgg/bridge 0.0.11 → 0.0.13

package/src/presence/rosterSync.test.ts

@@ -0,0 +1,179 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+import type { BridgeContext } from "../context";
+import type { BridgeValues } from "../core";
+import { BridgeEventName } from "../protocol";
+import { createRosterSync } from "./rosterSync";
+
+interface Player {
+	id: string;
+	name: string;
+}
+
+interface Emitted {
+	event: string;
+	payload: BridgeValues | undefined;
+}
+
+const emitted: Emitted[] = [];
+
+const context = {
+	emit(event: string, payload?: BridgeValues) {
+		emitted.push({
+			event,
+			payload,
+		});
+	},
+} as unknown as BridgeContext;
+
+const roster = () => {
+	return createRosterSync<Player>({
+		id: (player) => player.id,
+		presenceOf: (player) => {
+			return {
+				player: player.name,
+				steamId: player.id,
+			};
+		},
+	});
+};
+
+beforeEach(() => {
+	emitted.length = 0;
+});
+
+describe("createRosterSync", () => {
+	test("emits a join for every player of the first sample", () => {
+		const sync = roster();
+
+		sync.sync(context, [
+			{
+				id: "1",
+				name: "sara",
+			},
+			{
+				id: "2",
+				name: "omar",
+			},
+		]);
+
+		expect(emitted).toEqual([
+			{
+				event: BridgeEventName.PlayerJoined,
+				payload: {
+					player: "sara",
+					steamId: "1",
+				},
+			},
+			{
+				event: BridgeEventName.PlayerJoined,
+				payload: {
+					player: "omar",
+					steamId: "2",
+				},
+			},
+		]);
+	});
+
+	test("stays quiet while the roster does not change", () => {
+		const sync = roster();
+		const rows = [
+			{
+				id: "1",
+				name: "sara",
+			},
+		];
+
+		sync.sync(context, rows);
+		emitted.length = 0;
+		sync.sync(context, rows);
+
+		expect(emitted).toEqual([]);
+	});
+
+	test("emits a leave carrying the presence the player had", () => {
+		const sync = roster();
+
+		sync.sync(context, [
+			{
+				id: "1",
+				name: "sara",
+			},
+		]);
+		emitted.length = 0;
+		sync.sync(context, []);
+
+		expect(emitted).toEqual([
+			{
+				event: BridgeEventName.PlayerLeft,
+				payload: {
+					player: "sara",
+					steamId: "1",
+				},
+			},
+		]);
+	});
+
+	test("emits both sides of a swap in one sample", () => {
+		const sync = roster();
+
+		sync.sync(context, [
+			{
+				id: "1",
+				name: "sara",
+			},
+		]);
+		emitted.length = 0;
+		sync.sync(context, [
+			{
+				id: "2",
+				name: "omar",
+			},
+		]);
+
+		expect(emitted.map((entry) => entry.event)).toEqual([
+			BridgeEventName.PlayerJoined,
+			BridgeEventName.PlayerLeft,
+		]);
+	});
+
+	test("reports who it believes is online", () => {
+		const sync = roster();
+
+		sync.sync(context, [
+			{
+				id: "1",
+				name: "sara",
+			},
+		]);
+
+		expect(sync.online()).toEqual([
+			{
+				id: "1",
+				name: "sara",
+			},
+		]);
+
+		sync.clear();
+
+		expect(sync.online()).toEqual([]);
+	});
+
+	test("emits a fresh join after a clear", () => {
+		const sync = roster();
+		const rows = [
+			{
+				id: "1",
+				name: "sara",
+			},
+		];
+
+		sync.sync(context, rows);
+		sync.clear();
+		emitted.length = 0;
+		sync.sync(context, rows);
+
+		expect(emitted.map((entry) => entry.event)).toEqual([
+			BridgeEventName.PlayerJoined,
+		]);
+	});
+});

package/src/presence/rosterSync.ts

@@ -0,0 +1,57 @@
+import type { BridgeContext } from "../context";
+import type { BridgeValues } from "../core";
+import { BridgeEventName } from "../protocol";
+
+export interface RosterSyncOptions<Row> {
+	id(row: Row): string;
+	presenceOf(row: Row): BridgeValues;
+}
+
+export interface RosterSync<Row> {
+	sync(context: BridgeContext, rows: Row[]): void;
+	clear(): void;
+	online(): Row[];
+}
+
+export const createRosterSync = <Row>(options: RosterSyncOptions<Row>): RosterSync<Row> => {
+	const present = new Map<string, Row>();
+
+	return {
+		sync(context, rows) {
+			const current = new Map(
+				rows.map((row) => [
+					options.id(row),
+					row,
+				]),
+			);
+
+			for (const [id, row] of current) {
+				if (!present.has(id)) {
+					context.emit(BridgeEventName.PlayerJoined, options.presenceOf(row));
+				}
+			}
+
+			for (const [id, row] of present) {
+				if (!current.has(id)) {
+					context.emit(BridgeEventName.PlayerLeft, options.presenceOf(row));
+				}
+			}
+
+			present.clear();
+
+			for (const [id, row] of current) {
+				present.set(id, row);
+			}
+		},
+
+		clear() {
+			present.clear();
+		},
+
+		online() {
+			return [
+				...present.values(),
+			];
+		},
+	};
+};

package/src/probes/index.ts

@@ -1 +1,10 @@
+export type {
+	BridgeA2sInfo,
+	BridgeMinecraftPingStatus,
+	BridgePingPlayers,
+	BridgeRaknetPingStatus,
+} from "../context";
+export { BridgeProbeCode, BridgeProbeError } from "../core";
 export * from "./a2s";
+export * from "./minecraftPing";
+export * from "./raknetPing";

package/src/probes/minecraftPing.test.ts

@@ -0,0 +1,344 @@
+import { describe, expect, test } from "bun:test";
+import { BridgeProbeCode, BridgeProbeError } from "../core";
+import { parseStatus, probeMinecraftPing } from "./minecraftPing";
+
+const HOST = "127.0.0.1";
+
+const CLOSED_PORT = 59_441;
+
+const varInt = (value: number) => {
+	const bytes: number[] = [];
+
+	let current = value >>> 0;
+
+	while (true) {
+		if ((current & ~0x7f) === 0) {
+			bytes.push(current);
+
+			return bytes;
+		}
+
+		bytes.push((current & 0x7f) | 0x80);
+
+		current >>>= 7;
+	}
+};
+
+const readVarInt = (view: Uint8Array, offset: number) => {
+	let value = 0;
+	let size = 0;
+
+	while (size < 5) {
+		const byte = view[offset + size];
+
+		if (byte === undefined) {
+			throw new Error("varint is truncated");
+		}
+
+		value |= (byte & 0x7f) << (7 * size);
+		size += 1;
+
+		if ((byte & 0x80) === 0) {
+			return {
+				value,
+				size,
+			};
+		}
+	}
+
+	throw new Error("varint is malformed");
+};
+
+const response = (payload: unknown, packetId = 0x00) => {
+	const json = new TextEncoder().encode(JSON.stringify(payload));
+
+	const body = [
+		...varInt(packetId),
+		...varInt(json.length),
+		...json,
+	];
+
+	return new Uint8Array([
+		...varInt(body.length),
+		...body,
+	]);
+};
+
+const status = {
+	players: {
+		online: 3,
+		max: 20,
+	},
+	version: {
+		name: "1.21.11",
+	},
+	description: "A Serverk Minecraft Server",
+};
+
+const handshakeServerName = (frame: Uint8Array) => {
+	const length = readVarInt(frame, 0);
+	const packetId = readVarInt(frame, length.size);
+	const protocol = readVarInt(frame, length.size + packetId.size);
+	const address = readVarInt(frame, length.size + packetId.size + protocol.size);
+	const start = length.size + packetId.size + protocol.size + address.size;
+
+	return new TextDecoder().decode(frame.subarray(start, start + address.value));
+};
+
+const listen = async (reply: Uint8Array | null, onServerName?: (serverName: string) => void) => {
+	return Bun.listen({
+		hostname: HOST,
+		port: 0,
+		socket: {
+			data(socket, data) {
+				if (onServerName) {
+					onServerName(handshakeServerName(data));
+				}
+
+				if (reply) {
+					socket.write(reply);
+				}
+			},
+			error() {},
+		},
+	});
+};
+
+describe("reading a status response off the wire", () => {
+	test("a complete response gives the player counts, the version and the motd", () => {
+		expect(parseStatus(response(status))).toEqual({
+			players: {
+				online: 3,
+				max: 20,
+			},
+			version: "1.21.11",
+			description: "A Serverk Minecraft Server",
+		});
+	});
+
+	test("a response longer than one packet is still read, because the frame carries its own length", () => {
+		const packet = response(status);
+		const padded = new Uint8Array(packet.length + 4);
+
+		padded.set(packet);
+
+		expect(parseStatus(padded)?.players).toEqual({
+			online: 3,
+			max: 20,
+		});
+	});
+
+	test("a modern description object is read through its text", () => {
+		expect(
+			parseStatus(
+				response({
+					...status,
+					description: {
+						text: "hello",
+					},
+				}),
+			)?.description,
+		).toBe("hello");
+	});
+
+	test("a description we cannot read is dropped rather than failing the sample", () => {
+		expect(
+			parseStatus(
+				response({
+					...status,
+					description: {
+						extra: [],
+					},
+				}),
+			)?.description,
+		).toBeNull();
+		expect(
+			parseStatus(
+				response({
+					...status,
+					description: null,
+				}),
+			)?.description,
+		).toBeNull();
+	});
+
+	test("a missing version name is dropped rather than failing the sample", () => {
+		expect(
+			parseStatus(
+				response({
+					players: status.players,
+				}),
+			)?.version,
+		).toBeNull();
+	});
+
+	test("fractional or negative counts are clamped to whole players", () => {
+		expect(
+			parseStatus(
+				response({
+					players: {
+						online: -1,
+						max: 20.7,
+					},
+				}),
+			)?.players,
+		).toEqual({
+			online: 0,
+			max: 20,
+		});
+	});
+
+	test("a response we have not fully received yet asks for more bytes", () => {
+		const packet = response(status);
+
+		expect(parseStatus(new Uint8Array(0))).toBeNull();
+		expect(parseStatus(packet.subarray(0, 1))).toBeNull();
+		expect(parseStatus(packet.subarray(0, packet.length - 4))).toBeNull();
+	});
+
+	test("a large payload whose length needs two varint bytes is read whole", () => {
+		const long = {
+			players: status.players,
+			description: "n".repeat(400),
+		};
+
+		expect(parseStatus(response(long))?.description).toBe(long.description);
+	});
+
+	test("a packet that is not a status response is refused", () => {
+		expect(() => parseStatus(response(status, 0x01))).toThrow();
+	});
+
+	test("a response with no player counts is refused, because a sample without them is a lie", () => {
+		expect(() =>
+			parseStatus(
+				response({
+					version: {
+						name: "1.21.11",
+					},
+				}),
+			),
+		).toThrow();
+	});
+});
+
+describe("probeMinecraftPing", () => {
+	test("answers with the status a listening server sends back", async () => {
+		const server = await listen(response(status));
+
+		try {
+			const sample = await probeMinecraftPing(
+				{
+					address: HOST,
+					port: server.port,
+				},
+				2000,
+			);
+
+			expect(sample.players).toEqual({
+				online: 3,
+				max: 20,
+			});
+			expect(sample.version).toBe("1.21.11");
+			expect(sample.latencyMs).toBeGreaterThanOrEqual(0);
+		} finally {
+			server.stop(true);
+		}
+	});
+
+	test("puts the server name in the handshake so a virtual host still answers", async () => {
+		const seen: string[] = [];
+
+		const server = await listen(response(status), (serverName) => {
+			seen.push(serverName);
+		});
+
+		try {
+			await probeMinecraftPing(
+				{
+					address: HOST,
+					port: server.port,
+					serverName: "play.example.com",
+				},
+				2000,
+			);
+
+			expect(seen.at(0)).toBe("play.example.com");
+		} finally {
+			server.stop(true);
+		}
+	});
+
+	test("falls back to the address when no server name is given", async () => {
+		const seen: string[] = [];
+
+		const server = await listen(response(status), (serverName) => {
+			seen.push(serverName);
+		});
+
+		try {
+			await probeMinecraftPing(
+				{
+					address: HOST,
+					port: server.port,
+				},
+				2000,
+			);
+
+			expect(seen.at(0)).toBe(HOST);
+		} finally {
+			server.stop(true);
+		}
+	});
+
+	test("rejects as unreachable when nothing listens on the port", async () => {
+		const error = await probeMinecraftPing(
+			{
+				address: HOST,
+				port: CLOSED_PORT,
+			},
+			2000,
+		).catch((reason: unknown) => reason);
+
+		expect(error).toBeInstanceOf(BridgeProbeError);
+		expect((error as BridgeProbeError).code).toBe(BridgeProbeCode.Unreachable);
+	});
+
+	test("times out against a port that never answers", async () => {
+		const silent = await listen(null);
+
+		try {
+			const error = await probeMinecraftPing(
+				{
+					address: HOST,
+					port: silent.port,
+				},
+				250,
+			).catch((reason: unknown) => reason);
+
+			expect(error).toBeInstanceOf(BridgeProbeError);
+			expect((error as BridgeProbeError).code).toBe(BridgeProbeCode.TimedOut);
+		} finally {
+			silent.stop(true);
+		}
+	});
+
+	test("rejects a reply that is not a status response", async () => {
+		const noisy = await listen(response(status, 0x01));
+
+		try {
+			const error = await probeMinecraftPing(
+				{
+					address: HOST,
+					port: noisy.port,
+				},
+				2000,
+			).catch((reason: unknown) => reason);
+
+			expect(error).toBeInstanceOf(BridgeProbeError);
+			expect((error as BridgeProbeError).code).toBe(BridgeProbeCode.Malformed);
+		} finally {
+			noisy.stop(true);
+		}
+	});
+});