84 lines
4.7 KiB
TypeScript
84 lines
4.7 KiB
TypeScript
import { db } from '../db/index.js';
|
|
import { parseGameEvent, type GameTelemetry } from '../../telemetry.js';
|
|
import { ONLINE_MAX_MS } from '../../server-freshness.js';
|
|
import { rconGetPlayerCount, rconStatusResult } from '../integrations/rcon.js';
|
|
|
|
export interface TelemetryEvidence { players: number; map: string; receivedAt: string }
|
|
|
|
/** Reports from before the latest lifecycle submission describe the old process. */
|
|
export function latestGameSubmission(server: string): string | null {
|
|
return (db().prepare(`SELECT MAX(at) AS at FROM (
|
|
SELECT submitted_at AS at FROM server_deployments WHERE server=? AND server_deleted_at IS NULL AND action IN ('create','start','restart','rebuild')
|
|
UNION ALL SELECT requested_at AS at FROM restart_rollout WHERE server=?)`).get(server, server) as { at: string | null }).at;
|
|
}
|
|
|
|
export function telemetryReport(server: string): GameTelemetry | null {
|
|
const row = db().prepare('SELECT received_at, payload FROM server_telemetry WHERE server = ?').get(server) as
|
|
{ received_at: string; payload: string | null } | undefined;
|
|
if (!row?.payload) return null;
|
|
try {
|
|
const saved = JSON.parse(row.payload) as GameTelemetry;
|
|
const event = parseGameEvent(saved);
|
|
return event.server === server ? { ...event, receivedAt: row.received_at, timing: saved.timing } : null;
|
|
} catch { return null; }
|
|
}
|
|
|
|
/** Only validated, recently received reports can establish current game state. */
|
|
export function telemetryEvidence(server: string, after: string | null = latestGameSubmission(server)): TelemetryEvidence | null {
|
|
const report = telemetryReport(server);
|
|
if (!report) return null;
|
|
const received = Date.parse(report.receivedAt);
|
|
const age = Date.now() - received;
|
|
if (!Number.isFinite(age) || age < 0 || age > ONLINE_MAX_MS) return null;
|
|
if (after && (!Number.isFinite(Date.parse(after)) || received <= Date.parse(after))) return null;
|
|
return { players: report.players.length, map: report.map, receivedAt: report.receivedAt };
|
|
}
|
|
|
|
/** Positive occupancy from either source always vetoes an empty-server claim. */
|
|
export async function probePlayerCount(server: string): Promise<number | null> {
|
|
return (await probePlayerEvidence(server)).players;
|
|
}
|
|
|
|
export interface PlayerEvidence {
|
|
players: number | null;
|
|
source: 'rcon' | 'telemetry' | null;
|
|
observedAt: string;
|
|
receivedAt?: string;
|
|
}
|
|
|
|
/** The same eligibility decision, with provenance from the probes already performed. */
|
|
export async function probePlayerEvidence(server: string): Promise<PlayerEvidence> {
|
|
const fromTelemetry = (value: TelemetryEvidence): PlayerEvidence => ({
|
|
players: value.players, source: 'telemetry', observedAt: new Date().toISOString(), receivedAt: value.receivedAt
|
|
});
|
|
const occupied = telemetryEvidence(server);
|
|
if (occupied && occupied.players > 0) return fromTelemetry(occupied);
|
|
const players = await rconGetPlayerCount(server).catch(() => null);
|
|
// Read after the network request: a player may join while RCON is pending.
|
|
const telemetry = telemetryEvidence(server);
|
|
if (players !== null && players > 0) return { players, source: 'rcon', observedAt: new Date().toISOString() };
|
|
if (telemetry && telemetry.players > 0) return fromTelemetry(telemetry);
|
|
if (players === 0) return { players, source: 'rcon', observedAt: new Date().toISOString() };
|
|
if (telemetry?.players === 0) return fromTelemetry(telemetry);
|
|
return { players: null, source: null, observedAt: new Date().toISOString() };
|
|
}
|
|
|
|
/** Komodo readiness remains a caller prerequisite. Old-process telemetry is excluded. */
|
|
export async function probeServerStatus(server: string, after?: string | null): Promise<
|
|
{ ok: true; players: number; map: string | null; source: 'rcon' | 'telemetry'; observedAt: string; receivedAt?: string } | { ok: false; reason: string; observedAt: string }
|
|
> {
|
|
const current = telemetryEvidence(server, after);
|
|
if (current) return { ok: true, ...current, source: 'telemetry', observedAt: new Date().toISOString() };
|
|
let reason = 'RCON unavailable';
|
|
try {
|
|
const rcon = await rconStatusResult(server);
|
|
const latest = telemetryEvidence(server, after);
|
|
if (latest) return { ok: true, ...latest, source: 'telemetry', observedAt: new Date().toISOString() };
|
|
if (rcon.ok) return { ok: true, players: rcon.status.players, map: rcon.status.map, source: 'rcon', observedAt: new Date().toISOString() };
|
|
reason = rcon.reason;
|
|
} catch (err) { reason = (err as Error).message; }
|
|
const telemetry = telemetryEvidence(server, after);
|
|
return telemetry ? { ok: true, ...telemetry, source: 'telemetry', observedAt: new Date().toISOString() }
|
|
: { ok: false, reason, observedAt: new Date().toISOString() };
|
|
}
|