@serverkgg/bridge 0.0.1

package/src/runtime/serve.ts

@@ -0,0 +1,294 @@
+import { chmod, chown, mkdir, rm } from "node:fs/promises";
+import { BridgeDesired, BridgeRuntime } from "../core";
+import type { BridgeDriver } from "../modules";
+import {
+	BRIDGE_INSTALL_ERROR_LIMIT,
+	BRIDGE_VERSION,
+	type BridgeConfig,
+	type BridgeSampleResult,
+	type BridgeStatus,
+} from "../protocol";
+import { configPath, readConfig, socketPath, statePath } from "./bridgeConfigReader";
+import { createContext } from "./bridgeContext";
+import { validateDriver } from "./bridgeDriver";
+import { createEventRing } from "./bridgeEvents";
+import { errorText, log } from "./bridgeLog";
+import { createRegistry } from "./bridgeRegistry";
+import { createServer } from "./bridgeServer";
+import { readDesired, writeDesired } from "./bridgeState";
+import { createSupervisor } from "./bridgeSupervisor";
+
+const VOLUME_MODE = 0o2775;
+
+const RUN_MODE = 0o700;
+
+const SOCKET_MODE = 0o600;
+
+const DEFAULT_STOP_TIMEOUT_SECONDS = 30;
+
+const DEFAULT_SAMPLE_REFRESH_SECONDS = 30;
+
+const prepare = async (config: BridgeConfig) => {
+	await mkdir(config.cwd, {
+		recursive: true,
+	});
+
+	await mkdir(config.run, {
+		recursive: true,
+	});
+
+	await chmod(config.run, RUN_MODE);
+
+	await rm(socketPath(config), {
+		force: true,
+	});
+
+	if (typeof process.getuid === "function" && process.getuid() !== 0) {
+		return;
+	}
+
+	await chown(config.cwd, config.gameUid, config.gameGid);
+	await chmod(config.cwd, VOLUME_MODE);
+};
+
+export const serve = async (driver: BridgeDriver) => {
+	process.umask(0o002);
+
+	validateDriver(driver);
+
+	const config = await readConfig(configPath());
+
+	await prepare(config);
+
+	const desired = await readDesired(statePath(config));
+
+	let installError: string | null = null;
+
+	const supervisor = createSupervisor({
+		cwd: config.cwd,
+		uid: config.gameUid,
+		gid: config.gameGid,
+		stopTimeoutSeconds: driver.lifecycle.stopTimeoutSeconds ?? DEFAULT_STOP_TIMEOUT_SECONDS,
+		ready: driver.lifecycle.ready,
+		onLog: log,
+		async resolveCommand() {
+			return await driver.lifecycle.command(context);
+		},
+		async gracefulStop() {
+			await driver.lifecycle.stop?.(context);
+		},
+		onReady() {
+			void Promise.resolve(driver.lifecycle.onReady?.(context)).catch((error: unknown) => {
+				log("lifecycle ready hook failed", {
+					error: errorText(error),
+				});
+			});
+		},
+	});
+
+	const ring = createEventRing(driver.events, supervisor);
+
+	const context = createContext(config, supervisor, {
+		onLog: log,
+		onEmit(event, payload) {
+			ring.emit(event, payload);
+		},
+	});
+
+	const registry = createRegistry(driver, context, supervisor, ring);
+
+	let current = desired;
+
+	const status = (): BridgeStatus => {
+		return {
+			version: BRIDGE_VERSION,
+			runtime: supervisor.runtime,
+			desired: current,
+			exitCode: supervisor.exitCode,
+			restarts: supervisor.restarts,
+			installError,
+		};
+	};
+
+	supervisor.setRuntime(BridgeRuntime.Installing);
+
+	let sampled: {
+		value: BridgeSampleResult;
+		expiresAt: number;
+	} | null = null;
+
+	const sample = async (): Promise<BridgeSampleResult> => {
+		const query = driver.query;
+
+		if (!query) {
+			throw new Error("this game declares no query");
+		}
+
+		if (!supervisor.running) {
+			return {
+				online: null,
+				max: null,
+			};
+		}
+
+		const stamp = performance.now();
+
+		if (sampled && sampled.expiresAt > stamp) {
+			return sampled.value;
+		}
+
+		const result = await query.sample(context);
+
+		const value: BridgeSampleResult = {
+			online: result.online,
+			max: result.max,
+		};
+
+		sampled = {
+			value,
+			expiresAt: stamp + (query.refreshSeconds ?? DEFAULT_SAMPLE_REFRESH_SECONDS) * 1000,
+		};
+
+		return value;
+	};
+
+	const server = createServer({
+		socket: socketPath(config),
+		token: config.token,
+		onLog: log,
+		onStatus: status,
+		onManifest() {
+			return registry.manifest();
+		},
+		async onStart() {
+			current = BridgeDesired.Running;
+
+			await writeDesired(statePath(config), current);
+			await supervisor.start();
+		},
+		async onStop() {
+			current = BridgeDesired.Stopped;
+
+			await writeDesired(statePath(config), current);
+			await supervisor.stop();
+		},
+		async onCommand(input, expect, timeoutMs) {
+			return await supervisor.command(input, {
+				expect: expect === undefined ? undefined : new RegExp(expect),
+				timeoutMs,
+			});
+		},
+		async onInvoke(module, action, args) {
+			return await registry.invoke(module, action, args);
+		},
+		onEvents(cursor) {
+			return ring.drain(cursor);
+		},
+		async onSample() {
+			return await sample();
+		},
+		async onQuiesce() {
+			const backup = driver.backup;
+
+			if (!backup?.quiesce) {
+				return {
+					supported: false,
+					quiesced: false,
+					settleSeconds: 0,
+				};
+			}
+
+			if (!supervisor.running) {
+				return {
+					supported: true,
+					quiesced: false,
+					settleSeconds: 0,
+				};
+			}
+
+			await backup.quiesce(context);
+
+			return {
+				supported: true,
+				quiesced: true,
+				settleSeconds: backup.settleSeconds ?? 0,
+			};
+		},
+		async onRelease() {
+			if (supervisor.running) {
+				await driver.backup?.release?.(context);
+			}
+		},
+	});
+
+	await chmod(socketPath(config), SOCKET_MODE);
+
+	log("bridge ready", {
+		code: config.code,
+		desired: current,
+	});
+
+	let stopping = false;
+
+	const shutdown = async (signal: string) => {
+		if (stopping) {
+			return;
+		}
+
+		stopping = true;
+
+		log("shutting down", {
+			signal,
+		});
+
+		await supervisor.stop();
+
+		server.stop(true);
+
+		await rm(socketPath(config), {
+			force: true,
+		});
+
+		process.exit(0);
+	};
+
+	process.on("SIGTERM", () => {
+		void shutdown("SIGTERM");
+	});
+
+	process.on("SIGINT", () => {
+		void shutdown("SIGINT");
+	});
+
+	log("installing");
+
+	try {
+		await driver.install.run(context);
+
+		log("install complete");
+	} catch (error) {
+		installError = errorText(error).slice(0, BRIDGE_INSTALL_ERROR_LIMIT);
+
+		supervisor.setRuntime(BridgeRuntime.Crashed);
+
+		log("install failed", {
+			error: installError,
+		});
+
+		return;
+	}
+
+	supervisor.setRuntime(current === BridgeDesired.Running ? BridgeRuntime.Starting : BridgeRuntime.Stopped);
+
+	if (current === BridgeDesired.Running) {
+		try {
+			await supervisor.start();
+		} catch (error) {
+			supervisor.setRuntime(BridgeRuntime.Crashed);
+
+			log("start failed", {
+				error: errorText(error),
+			});
+		}
+	}
+};

package/src/utils/glob.ts

@@ -0,0 +1,62 @@
+const segmentToRegex = (segment: string) => {
+	let out = "";
+
+	for (const char of segment) {
+		if (char === "*") {
+			out += "[^/]*";
+		} else if (char === "?") {
+			out += "[^/]";
+		} else {
+			out += char.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+		}
+	}
+
+	return out;
+};
+
+export const compileGlob = (glob: string) => {
+	const segments = glob.split("/");
+
+	let pattern = "";
+
+	for (let index = 0; index < segments.length; index += 1) {
+		const segment = segments[index];
+
+		if (segment === undefined) {
+			continue;
+		}
+
+		const first = index === 0;
+		const last = index === segments.length - 1;
+
+		if (segment === "**") {
+			if (first && last) {
+				pattern += ".*";
+			} else if (first) {
+				pattern += "(?:.*/)?";
+			} else if (last) {
+				pattern += "(?:/.*)?";
+			} else {
+				pattern += "/(?:.*/)?";
+			}
+
+			continue;
+		}
+
+		if (!first && segments[index - 1] !== "**") {
+			pattern += "/";
+		}
+
+		pattern += segmentToRegex(segment);
+	}
+
+	return new RegExp(`^${pattern}$`);
+};
+
+export const compileGlobs = (globs: string[]) => {
+	return globs.map(compileGlob);
+};
+
+export const matchesAny = (path: string, patterns: RegExp[]) => {
+	return patterns.some((pattern) => pattern.test(path));
+};

package/src/utils/index.ts

@@ -0,0 +1 @@
+export * from "./glob";