123 lines
6.3 KiB
TypeScript
123 lines
6.3 KiB
TypeScript
import { randomUUID } from 'node:crypto';
|
|
import { db } from '../db/index.js';
|
|
|
|
type KeyGame = 't5' | 't6';
|
|
export interface ServerKey {
|
|
id: string;
|
|
game: KeyGame;
|
|
label: string;
|
|
updated_at: string;
|
|
assigned_servers: string[];
|
|
}
|
|
|
|
function validGame(game: unknown): asserts game is KeyGame {
|
|
if (game !== 't5' && game !== 't6') throw new Error('Choose T5 or T6 for the server key');
|
|
}
|
|
|
|
function normalizedKey(key: unknown): string {
|
|
if (typeof key !== 'string' || !key.trim() || key.trim().length > 512 || /\s/.test(key.trim())) {
|
|
throw new Error('Enter a server key without whitespace (maximum 512 characters)');
|
|
}
|
|
return key.trim();
|
|
}
|
|
|
|
function normalizedLabel(label: unknown): string {
|
|
if (typeof label !== 'string' || label.trim().length > 160 || /[\r\n]/.test(label)) {
|
|
throw new Error('Enter a key label with at most 160 characters');
|
|
}
|
|
return label.trim();
|
|
}
|
|
|
|
export function listServerKeys(): ServerKey[] {
|
|
const rows = db().prepare('SELECT id,game,label,updated_at FROM server_keys ORDER BY game,label,id').all() as Omit<ServerKey, 'assigned_servers'>[];
|
|
const assignments = db().prepare(`SELECT DISTINCT k.id AS key_id,l.server_id FROM server_keys k
|
|
JOIN server_keys occupied ON occupied.pluto_key=k.pluto_key JOIN server_key_leases l ON l.key_id=occupied.id
|
|
ORDER BY l.server_id`).all() as { key_id: string; server_id: string }[];
|
|
const byKey = new Map<string, string[]>();
|
|
for (const lease of assignments) {
|
|
const servers = byKey.get(lease.key_id) ?? [];
|
|
servers.push(lease.server_id);
|
|
byKey.set(lease.key_id, servers);
|
|
}
|
|
return rows.map(row => ({ ...row, assigned_servers: byKey.get(row.id) ?? [] }));
|
|
}
|
|
|
|
export function getServerKey(serverId: string): string | undefined {
|
|
return (db().prepare(`SELECT k.pluto_key FROM server_key_leases l
|
|
JOIN server_keys k ON k.id=l.key_id WHERE l.server_id=? AND l.is_current=1`).get(serverId) as { pluto_key: string } | undefined)?.pluto_key;
|
|
}
|
|
|
|
/** Saving a credential twice cannot increase available capacity. */
|
|
export function saveServerKey(game: unknown, key: unknown, label?: unknown): string {
|
|
validGame(game);
|
|
const credential = normalizedKey(key);
|
|
const keyLabel = label === undefined ? undefined : normalizedLabel(label);
|
|
return db().transaction(() => {
|
|
const existing = db().prepare('SELECT id FROM server_keys WHERE game=? AND pluto_key=?').get(game, credential) as { id: string } | undefined;
|
|
if (existing) {
|
|
if (keyLabel !== undefined) db().prepare("UPDATE server_keys SET label=?,updated_at=datetime('now') WHERE id=?").run(keyLabel, existing.id);
|
|
return existing.id;
|
|
}
|
|
const id = randomUUID();
|
|
db().prepare('INSERT INTO server_keys(id,game,label,pluto_key) VALUES(?,?,?,?)').run(id, game, keyLabel ?? '', credential);
|
|
return id;
|
|
}).immediate();
|
|
}
|
|
|
|
// Compare the credential as well as its row: a mistakenly imported copy in
|
|
// another game's pool must not permit simultaneous use of the same key.
|
|
const availableKey = `NOT EXISTS (SELECT 1 FROM server_key_leases l
|
|
JOIN server_keys occupied ON occupied.id=l.key_id
|
|
WHERE occupied.pluto_key=k.pluto_key AND (l.server_id!=@server OR l.is_current=0))`;
|
|
|
|
export function serverKeyPool(game: KeyGame, serverId?: string): { total: number; available: number } {
|
|
validGame(game);
|
|
return db().prepare(`SELECT COUNT(*) AS total,
|
|
COALESCE(SUM(CASE WHEN ${availableKey} THEN 1 ELSE 0 END),0) AS available
|
|
FROM server_keys k WHERE k.game=@game`).get({ game, server: serverId ?? '' }) as { total: number; available: number };
|
|
}
|
|
|
|
export function availableServerKeyCount(game: KeyGame): number {
|
|
return serverKeyPool(game).available;
|
|
}
|
|
|
|
/** Called within launch admission; the write lock prevents competing launches sharing a key. */
|
|
export function reserveServerKey(serverId: string, game: KeyGame, suppliedKey?: unknown): string {
|
|
validGame(game);
|
|
if (!serverId) throw new Error('Choose a server for the key reservation');
|
|
const credential = suppliedKey === undefined || suppliedKey === null || (typeof suppliedKey === 'string' && !suppliedKey.trim())
|
|
? undefined : normalizedKey(suppliedKey);
|
|
return db().transaction(() => {
|
|
const existing = db().prepare(`SELECT k.game,k.pluto_key FROM server_key_leases l
|
|
JOIN server_keys k ON k.id=l.key_id WHERE l.server_id=? AND l.is_current=1`).get(serverId) as { game: KeyGame; pluto_key: string } | undefined;
|
|
if (existing) {
|
|
if (existing.game !== game) throw new Error('This server already has a key reserved for another game');
|
|
if (credential && credential !== existing.pluto_key) throw new Error('This server already has a reserved key; destroy it before changing its key');
|
|
return existing.pluto_key;
|
|
}
|
|
const requestedId = credential ? saveServerKey(game, credential) : null;
|
|
const key = db().prepare(`SELECT k.id,k.pluto_key FROM server_keys k WHERE k.game=@game
|
|
AND (@requestedId IS NULL OR k.id=@requestedId) AND ${availableKey}
|
|
ORDER BY k.updated_at,k.id LIMIT 1`).get({ game, server: serverId, requestedId }) as { id: string; pluto_key: string } | undefined;
|
|
if (!key) throw new Error(credential ? 'This server key is already reserved by another server'
|
|
: `No available ${game.toUpperCase()} server keys. Add a key or destroy a server to release one.`);
|
|
db().prepare('INSERT INTO server_key_leases(server_id,key_id) VALUES(?,?)').run(serverId, key.id);
|
|
return key.pluto_key;
|
|
}).immediate();
|
|
}
|
|
|
|
/** Only after confirmed destruction or a creation cancelled before any host mutation. */
|
|
export function releaseServerKey(serverId: string): boolean {
|
|
return db().prepare('DELETE FROM server_key_leases WHERE server_id=?').run(serverId).changes > 0;
|
|
}
|
|
|
|
export function removeServerKey(id: string): boolean {
|
|
return db().transaction(() => {
|
|
if (db().prepare(`SELECT 1 FROM server_keys k JOIN server_keys occupied ON occupied.pluto_key=k.pluto_key
|
|
JOIN server_key_leases l ON l.key_id=occupied.id WHERE k.id=?`).get(id)) {
|
|
throw new Error('This key is reserved by a server. Destroy that server before removing its key.');
|
|
}
|
|
return db().prepare('DELETE FROM server_keys WHERE id=?').run(id).changes > 0;
|
|
}).immediate();
|
|
}
|