Initial commit

lib/stores/stats.ts

@@ -0,0 +1,134 @@
+import { writable, get } from 'svelte/store';
+import { currentEnvironment, appendEnvParam } from './environment';
+
+export interface ContainerStats {
+	id: string;
+	name: string;
+	cpuPercent: number;
+	memoryUsage: number;
+	memoryLimit: number;
+	memoryPercent: number;
+}
+
+export interface HostInfo {
+	hostname: string;
+	ipAddress: string;
+	platform: string;
+	arch: string;
+	cpus: number;
+	totalMemory: number;
+	freeMemory: number;
+	uptime: number;
+	dockerVersion: string;
+	dockerContainers: number;
+	dockerContainersRunning: number;
+	dockerImages: number;
+}
+
+export interface HostMetric {
+	cpu_percent: number;
+	memory_percent: number;
+	memory_used: number;
+	memory_total: number;
+	timestamp: string;
+}
+
+// Historical data settings
+const MAX_HISTORY = 60; // 10 minutes at 10s intervals (server collects every 10s)
+const POLL_INTERVAL = 5000; // 5 seconds
+
+// Stores
+export const cpuHistory = writable<number[]>([]);
+export const memoryHistory = writable<number[]>([]);
+export const containerStats = writable<ContainerStats[]>([]);
+export const hostInfo = writable<HostInfo | null>(null);
+export const lastUpdated = writable<Date>(new Date());
+export const isCollecting = writable<boolean>(false);
+
+let pollInterval: ReturnType<typeof setInterval> | null = null;
+let envId: number | null = null;
+let initialFetchDone = false;
+
+// Subscribe to environment changes
+currentEnvironment.subscribe((env) => {
+	envId = env?.id ?? null;
+	// Reset history when environment changes
+	if (initialFetchDone) {
+		cpuHistory.set([]);
+		memoryHistory.set([]);
+		initialFetchDone = false;
+	}
+});
+
+// Helper for fetch with timeout
+async function fetchWithTimeout(url: string, timeout = 5000): Promise<any> {
+	const controller = new AbortController();
+	const timeoutId = setTimeout(() => controller.abort(), timeout);
+	try {
+		const response = await fetch(url, { signal: controller.signal });
+		clearTimeout(timeoutId);
+		return response.json();
+	} catch {
+		clearTimeout(timeoutId);
+		return null;
+	}
+}
+
+async function fetchStats() {
+	// Don't fetch if no environment is selected
+	if (!envId) return;
+
+	// Fire all fetches independently - don't block on slow ones
+	fetchWithTimeout(appendEnvParam('/api/containers/stats?limit=5', envId), 5000).then(data => {
+		if (Array.isArray(data)) {
+			containerStats.set(data);
+		}
+	});
+
+	fetchWithTimeout(appendEnvParam('/api/host', envId), 5000).then(data => {
+		if (data && !data.error) {
+			hostInfo.set(data);
+		}
+	});
+
+	fetchWithTimeout(appendEnvParam('/api/metrics?limit=60', envId), 5000).then(data => {
+		if (data?.metrics && data.metrics.length > 0) {
+			const metrics: HostMetric[] = data.metrics;
+			const cpuValues = metrics.map(m => m.cpu_percent);
+			const memValues = metrics.map(m => m.memory_percent);
+
+			cpuHistory.set(cpuValues.slice(-MAX_HISTORY));
+			memoryHistory.set(memValues.slice(-MAX_HISTORY));
+			initialFetchDone = true;
+		}
+	});
+
+	lastUpdated.set(new Date());
+}
+
+export function startStatsCollection() {
+	if (pollInterval) return; // Already running
+
+	isCollecting.set(true);
+	fetchStats(); // Initial fetch
+	pollInterval = setInterval(fetchStats, POLL_INTERVAL);
+}
+
+export function stopStatsCollection() {
+	if (pollInterval) {
+		clearInterval(pollInterval);
+		pollInterval = null;
+	}
+	isCollecting.set(false);
+}
+
+// Get current values
+export function getCurrentCpu(): number {
+	const history = get(cpuHistory);
+	return history.length > 0 ? history[history.length - 1] : 0;
+}
+
+export function getCurrentMemory(): number {
+	const history = get(memoryHistory);
+	return history.length > 0 ? history[history.length - 1] : 0;
+}