121 lines
6.6 KiB
TypeScript
121 lines
6.6 KiB
TypeScript
import { derived, get, writable } from 'svelte/store';
|
|
import { browser } from '$app/environment';
|
|
import { statusByServer, statusReceivedAt, serverTimeNow, syncServerTime, matchEventsByServer } from './servers.js';
|
|
import { watchSatisfied, type FleetServer, type FleetOperation, type LobbyWatch } from '$lib/fleet-overview.js';
|
|
import { serverTitle } from '../server-labels.js';
|
|
import { toast } from '../toast.js';
|
|
|
|
export const fleet = writable<{ servers: FleetServer[]; operations: FleetOperation[]; receivedAt: number }>({
|
|
servers: [], operations: [], receivedAt: 0
|
|
});
|
|
export const fleetError = writable('');
|
|
export const fleetRefreshing = writable(false);
|
|
export const fleetIntegrations = writable<{ rcon: boolean; komodo: boolean; rconTimeoutMs: number; defaultRconHost: string } | null>(null);
|
|
export const lobbyWatches = writable<LobbyWatch[]>([]);
|
|
|
|
export const fleetServers = derived([fleet, statusByServer, statusReceivedAt, matchEventsByServer], ([snapshot, live, received, matches]) =>
|
|
snapshot.servers.map(server => {
|
|
const status = received > snapshot.receivedAt ? live.get(server.name) : undefined;
|
|
const current = status ? { ...server, last_players: status.players, last_map: status.map,
|
|
last_gametype: status.gametype, last_seen_at: status.lastSeenAt, last_error: status.lastError,
|
|
roster: status.roster, health: status.health, endpoint: status.endpoint, replySnippet: status.replySnippet, active_since: status.activeSince,
|
|
inactive_since: status.inactiveSince, game_started_at: status.gameStartedAt,
|
|
game_ended_at: status.gameEndedAt } : server;
|
|
const match = matches.get(server.name);
|
|
// Apply lifecycle events immediately, until a newer status observes them
|
|
// or confirms that the lobby has emptied.
|
|
if (!match || Date.parse(match.receivedAt) <= Date.parse(current.last_seen_at ?? '')
|
|
|| match.receivedAt < (current.game_started_at ?? '')
|
|
|| match.receivedAt < (current.game_ended_at ?? '')) return current;
|
|
return { ...current, game_started_at: match.event === 'game_start' ? match.receivedAt : current.game_started_at,
|
|
game_ended_at: match.event === 'game_end' ? match.receivedAt : null };
|
|
}));
|
|
|
|
let inFlight: Promise<void> | null = null;
|
|
export function refreshFleet(): Promise<void> {
|
|
if (!browser) return Promise.resolve();
|
|
if (inFlight) return inFlight;
|
|
inFlight = (async () => {
|
|
fleetRefreshing.set(true);
|
|
const controller = new AbortController();
|
|
const timeout = setTimeout(() => controller.abort(), 12_000);
|
|
const requestedAt = Date.now();
|
|
try {
|
|
const responses = await Promise.all([
|
|
fetch('/api/servers', { signal: controller.signal }),
|
|
fetch('/api/fleet', { signal: controller.signal })
|
|
]);
|
|
if (responses.some(response => !response.ok)) throw new Error('Could not refresh Fleet. Retrying automatically.');
|
|
const [servers, operations] = await Promise.all(responses.map(response => response.json()));
|
|
syncServerTime(servers.serverNow);
|
|
fleetError.set('');
|
|
fleetIntegrations.set(servers.integrations);
|
|
fleet.set({ servers: servers.servers, operations: operations.operations, receivedAt: requestedAt });
|
|
} catch (error) {
|
|
fleetError.set(error instanceof Error && error.name !== 'AbortError'
|
|
? error.message : 'Fleet refresh timed out. Retrying automatically.');
|
|
} finally {
|
|
clearTimeout(timeout);
|
|
fleetRefreshing.set(false);
|
|
}
|
|
})().finally(() => { inFlight = null; });
|
|
return inFlight;
|
|
}
|
|
|
|
export function followLobby(server: string, kind: LobbyWatch['kind'], operation?: FleetOperation): void {
|
|
const id = `${server}:${kind}:${operation?.key ?? ''}`;
|
|
lobbyWatches.update(watches => watches.some(watch => watch.id === id) ? watches : [...watches, {
|
|
id, server, kind, operationKey: operation?.key,
|
|
href: operation?.href ?? `/servers/${encodeURIComponent(server)}`
|
|
}]);
|
|
toast('Watching this lobby while the app is open.');
|
|
}
|
|
|
|
export function cancelWatch(id: string): void {
|
|
lobbyWatches.update(watches => watches.filter(watch => watch.id !== id));
|
|
}
|
|
|
|
let stop: (() => void) | null = null;
|
|
export function startFleetMonitor(): () => void {
|
|
if (!browser || stop) return () => {};
|
|
try {
|
|
const saved: unknown = JSON.parse(sessionStorage.getItem('electric-cherry:lobby-watches') ?? '[]');
|
|
if (Array.isArray(saved)) lobbyWatches.set(saved.filter((watch): watch is LobbyWatch =>
|
|
watch && typeof watch.id === 'string' && typeof watch.server === 'string'
|
|
&& ['empty', 'online', 'operation'].includes(watch.kind)
|
|
&& typeof watch.href === 'string' && /^\/(servers|campaigns|deployments)\//.test(watch.href)
|
|
&& (watch.kind !== 'operation' || typeof watch.operationKey === 'string')));
|
|
} catch { /* Watches still work with session storage disabled. */ }
|
|
const stopSaving = lobbyWatches.subscribe(watches => {
|
|
try { sessionStorage.setItem('electric-cherry:lobby-watches', JSON.stringify(watches)); } catch { /* Optional storage. */ }
|
|
});
|
|
void refreshFleet();
|
|
const interval = setInterval(() => {
|
|
if (document.visibilityState !== 'hidden' || get(lobbyWatches).length) void refreshFleet();
|
|
}, 10_000);
|
|
const onFocus = () => { if (document.visibilityState === 'visible') void refreshFleet(); };
|
|
document.addEventListener('visibilitychange', onFocus);
|
|
const check = () => {
|
|
// Never complete a watch using an operation snapshot from a failed refresh.
|
|
if (get(fleetError)) return;
|
|
const snapshot = get(fleet);
|
|
if (!snapshot.receivedAt || Date.now() - snapshot.receivedAt > 30_000) return;
|
|
const servers = get(fleetServers);
|
|
for (const watch of get(lobbyWatches)) {
|
|
if (!watchSatisfied(watch, servers.find(server => server.name === watch.server), snapshot.operations, serverTimeNow())) continue;
|
|
const message = `${serverTitle(watch.server)} ${watch.kind === 'empty' ? 'is empty' : watch.kind === 'online' ? 'is back online' : 'has finished its operation'}.`;
|
|
cancelWatch(watch.id);
|
|
toast(message, { variant: 'success', ttl: 0, href: watch.href });
|
|
}
|
|
};
|
|
const unsubscribe = fleetServers.subscribe(check);
|
|
stop = () => {
|
|
clearInterval(interval);
|
|
document.removeEventListener('visibilitychange', onFocus);
|
|
unsubscribe();
|
|
stopSaving();
|
|
stop = null;
|
|
};
|
|
return stop;
|
|
}
|