mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-20 07:04:53 +00:00
321 lines
11 KiB
TypeScript
321 lines
11 KiB
TypeScript
import { useState, useEffect, useCallback, useRef } from 'react';
|
|
import { netcattyBridge } from '../../../infrastructure/services/netcattyBridge';
|
|
|
|
export interface DiskInfo {
|
|
mountPoint: string;
|
|
used: number; // Used in GB
|
|
total: number; // Total in GB
|
|
percent: number; // Usage percentage
|
|
}
|
|
|
|
export interface NetInterfaceInfo {
|
|
name: string; // Interface name (e.g., eth0, ens33)
|
|
rxBytes: number; // Total received bytes
|
|
txBytes: number; // Total transmitted bytes
|
|
rxSpeed: number; // Receive speed (bytes/sec)
|
|
txSpeed: number; // Transmit speed (bytes/sec)
|
|
}
|
|
|
|
export interface ProcessInfo {
|
|
pid: string;
|
|
memPercent: number;
|
|
command: string;
|
|
}
|
|
|
|
export interface ServerStats {
|
|
cpu: number | null; // CPU usage percentage (0-100)
|
|
cpuCores: number | null; // Number of CPU cores
|
|
cpuPerCore: number[]; // Per-core CPU usage array
|
|
memTotal: number | null; // Total memory in MB
|
|
memUsed: number | null; // Used memory in MB (excluding buffers/cache)
|
|
memFree: number | null; // Free memory in MB
|
|
memBuffers: number | null; // Buffers in MB
|
|
memCached: number | null; // Cached in MB
|
|
swapTotal: number | null; // Total swap in MB
|
|
swapUsed: number | null; // Used swap in MB
|
|
topProcesses: ProcessInfo[]; // Top 10 processes by memory
|
|
diskPercent: number | null; // Disk usage percentage for root partition
|
|
diskUsed: number | null; // Disk used in GB
|
|
diskTotal: number | null; // Total disk in GB
|
|
disks: DiskInfo[]; // All mounted disks
|
|
netRxSpeed: number; // Total network receive speed (bytes/sec)
|
|
netTxSpeed: number; // Total network transmit speed (bytes/sec)
|
|
latencyMs: number | null; // Approximate SSH stats round-trip latency
|
|
netInterfaces: NetInterfaceInfo[]; // Per-interface network stats
|
|
lastUpdated: number | null; // Timestamp of last successful update
|
|
}
|
|
|
|
interface UseServerStatsOptions {
|
|
sessionId: string;
|
|
enabled: boolean; // Whether stats collection is enabled (from settings)
|
|
refreshInterval: number; // Refresh interval in seconds
|
|
isSupportedOs: boolean; // Only collect stats for Linux/macOS servers
|
|
isConnected: boolean; // Only collect when connected
|
|
isVisible: boolean; // Pause background polling for hidden terminals
|
|
}
|
|
|
|
export function useServerStats({
|
|
sessionId,
|
|
enabled,
|
|
refreshInterval,
|
|
isSupportedOs,
|
|
isConnected,
|
|
isVisible,
|
|
}: UseServerStatsOptions) {
|
|
const [stats, setStats] = useState<ServerStats>({
|
|
cpu: null,
|
|
cpuCores: null,
|
|
cpuPerCore: [],
|
|
memTotal: null,
|
|
memUsed: null,
|
|
memFree: null,
|
|
memBuffers: null,
|
|
memCached: null,
|
|
swapTotal: null,
|
|
swapUsed: null,
|
|
topProcesses: [],
|
|
diskPercent: null,
|
|
diskUsed: null,
|
|
diskTotal: null,
|
|
disks: [],
|
|
netRxSpeed: 0,
|
|
netTxSpeed: 0,
|
|
latencyMs: null,
|
|
netInterfaces: [],
|
|
lastUpdated: null,
|
|
});
|
|
const [isLoading, setIsLoading] = useState(false);
|
|
const [error, setError] = useState<string | null>(null);
|
|
const intervalRef = useRef<ReturnType<typeof setInterval> | null>(null);
|
|
const isMountedRef = useRef(true);
|
|
const hasFetchedRef = useRef(false);
|
|
const connectedAtRef = useRef(0);
|
|
const fetchGenerationRef = useRef(0);
|
|
// Auto-disable polling after a few consecutive failures. This covers
|
|
// hosts the banner classifier could not identify (e.g. Juniper JUNOS,
|
|
// Arista EOS, Cisco NX-OS — all of which advertise themselves as
|
|
// OpenSSH but do not support the POSIX stats shell command). Without
|
|
// this, the hook would keep retrying forever and generate an AAA
|
|
// session log every refresh interval.
|
|
const CONSECUTIVE_FAILURE_LIMIT = 3;
|
|
const consecutiveFailuresRef = useRef(0);
|
|
const givenUpRef = useRef(false);
|
|
|
|
const fetchStats = useCallback(async () => {
|
|
if (!enabled || !isSupportedOs || !isConnected || !isVisible || !sessionId) {
|
|
return;
|
|
}
|
|
if (givenUpRef.current) {
|
|
return;
|
|
}
|
|
|
|
const bridge = netcattyBridge.get();
|
|
if (!bridge?.getServerStats) {
|
|
return;
|
|
}
|
|
|
|
const generation = ++fetchGenerationRef.current;
|
|
setIsLoading(true);
|
|
setError(null);
|
|
|
|
const markFailure = (message: string) => {
|
|
consecutiveFailuresRef.current += 1;
|
|
setError(message);
|
|
if (consecutiveFailuresRef.current >= CONSECUTIVE_FAILURE_LIMIT) {
|
|
// Stop polling this session. The caller's useEffect sees the
|
|
// givenUp flag via the next render cycle and we also clear the
|
|
// interval locally so no further ticks fire.
|
|
givenUpRef.current = true;
|
|
if (intervalRef.current) {
|
|
clearInterval(intervalRef.current);
|
|
intervalRef.current = null;
|
|
}
|
|
}
|
|
};
|
|
|
|
try {
|
|
const result = await bridge.getServerStats(sessionId);
|
|
|
|
// Discard stale responses from before a hide/show cycle or reconnect
|
|
if (!isMountedRef.current || generation !== fetchGenerationRef.current) return;
|
|
|
|
if (result.pending) {
|
|
// Transient "not ready yet" — e.g. a Mosh session whose SSH handshake
|
|
// hasn't finished, so the stats companion connection can't exist yet
|
|
// (issue #1198). Do NOT count this toward the consecutive-failure
|
|
// give-up, or a slow/manual handshake would permanently disable stats
|
|
// before the credentials become available. Just wait for the next poll.
|
|
return;
|
|
}
|
|
|
|
if (result.success && result.stats) {
|
|
hasFetchedRef.current = true;
|
|
consecutiveFailuresRef.current = 0;
|
|
setStats({
|
|
cpu: result.stats.cpu,
|
|
cpuCores: result.stats.cpuCores,
|
|
cpuPerCore: result.stats.cpuPerCore || [],
|
|
memTotal: result.stats.memTotal,
|
|
memUsed: result.stats.memUsed,
|
|
memFree: result.stats.memFree,
|
|
memBuffers: result.stats.memBuffers,
|
|
memCached: result.stats.memCached,
|
|
swapTotal: result.stats.swapTotal ?? null,
|
|
swapUsed: result.stats.swapUsed ?? null,
|
|
topProcesses: result.stats.topProcesses || [],
|
|
diskPercent: result.stats.diskPercent,
|
|
diskUsed: result.stats.diskUsed,
|
|
diskTotal: result.stats.diskTotal,
|
|
disks: result.stats.disks || [],
|
|
netRxSpeed: result.stats.netRxSpeed || 0,
|
|
netTxSpeed: result.stats.netTxSpeed || 0,
|
|
latencyMs: Number.isFinite(result.stats.latencyMs) ? result.stats.latencyMs : null,
|
|
netInterfaces: result.stats.netInterfaces || [],
|
|
lastUpdated: Date.now(),
|
|
});
|
|
} else if (result.error) {
|
|
markFailure(result.error);
|
|
} else {
|
|
// Response was not marked as success but has no error — treat as
|
|
// a soft failure. This happens e.g. when the stats shell pipeline
|
|
// returns a parse failure on a host that isn't a typical Linux
|
|
// distro (JUNOS, NX-OS, EOS).
|
|
markFailure('No stats returned');
|
|
}
|
|
} catch (err) {
|
|
if (isMountedRef.current && generation === fetchGenerationRef.current) {
|
|
markFailure(err instanceof Error ? err.message : 'Unknown error');
|
|
}
|
|
} finally {
|
|
if (isMountedRef.current && generation === fetchGenerationRef.current) {
|
|
setIsLoading(false);
|
|
}
|
|
}
|
|
}, [sessionId, enabled, isSupportedOs, isConnected, isVisible]);
|
|
|
|
// When the session changes (e.g., same tab reconnects to a different host
|
|
// while staying connected), reset the failure counter. Without this, a
|
|
// JUNOS session that tripped the counter would permanently suppress
|
|
// polling even after the tab reconnects to a Linux host.
|
|
useEffect(() => {
|
|
consecutiveFailuresRef.current = 0;
|
|
givenUpRef.current = false;
|
|
}, [sessionId]);
|
|
|
|
// Initial fetch and periodic refresh
|
|
useEffect(() => {
|
|
isMountedRef.current = true;
|
|
|
|
// Clear any existing interval
|
|
if (intervalRef.current) {
|
|
clearInterval(intervalRef.current);
|
|
intervalRef.current = null;
|
|
}
|
|
|
|
if (!enabled || !isSupportedOs || !isConnected) {
|
|
// Reset stats and fetch state when disabled or not connected.
|
|
// Also reset the give-up flag so that a reconnect (possibly to a
|
|
// different host at the same sessionId slot) gets a fresh chance.
|
|
hasFetchedRef.current = false;
|
|
connectedAtRef.current = 0;
|
|
consecutiveFailuresRef.current = 0;
|
|
givenUpRef.current = false;
|
|
|
|
setStats({
|
|
cpu: null,
|
|
cpuCores: null,
|
|
cpuPerCore: [],
|
|
memTotal: null,
|
|
memUsed: null,
|
|
memFree: null,
|
|
memBuffers: null,
|
|
memCached: null,
|
|
swapTotal: null,
|
|
swapUsed: null,
|
|
topProcesses: [],
|
|
diskPercent: null,
|
|
diskUsed: null,
|
|
diskTotal: null,
|
|
disks: [],
|
|
netRxSpeed: 0,
|
|
netTxSpeed: 0,
|
|
latencyMs: null,
|
|
netInterfaces: [],
|
|
lastUpdated: null,
|
|
});
|
|
return;
|
|
}
|
|
|
|
// Track when the connection became available for delay calculation
|
|
// (must be before the isVisible check so hidden tabs record connection time)
|
|
if (connectedAtRef.current === 0) {
|
|
connectedAtRef.current = Date.now();
|
|
}
|
|
|
|
if (!isVisible) {
|
|
return () => {
|
|
isMountedRef.current = false;
|
|
|
|
if (intervalRef.current) {
|
|
clearInterval(intervalRef.current);
|
|
intervalRef.current = null;
|
|
}
|
|
};
|
|
}
|
|
|
|
// Invalidate any in-flight request from a previous visible/hidden cycle
|
|
// so stale responses don't overwrite the reset network stats below.
|
|
fetchGenerationRef.current++;
|
|
|
|
// Fetch immediately when resuming from hidden, or with a delay on first connect.
|
|
// When resuming, reset delta-based network stats (both aggregate and per-interface)
|
|
// so the first sample doesn't show averaged-over-hidden-interval throughput.
|
|
if (hasFetchedRef.current) {
|
|
setStats(prev => ({
|
|
...prev,
|
|
netRxSpeed: 0,
|
|
netTxSpeed: 0,
|
|
netInterfaces: prev.netInterfaces.map(iface => ({ ...iface, rxSpeed: 0, txSpeed: 0 })),
|
|
}));
|
|
}
|
|
// Skip the warmup delay if the connection has been established long enough
|
|
// (e.g., tab was hidden while connected and is now becoming visible).
|
|
const connectionAge = Date.now() - connectedAtRef.current;
|
|
const needsWarmup = !hasFetchedRef.current && connectionAge < 2000;
|
|
// If we already gave up on this session (exceeded the consecutive
|
|
// failure limit), don't even schedule new timers on effect reruns
|
|
// such as visibility/tab-focus/settings changes. The cleanup at
|
|
// disconnect/sessionId change clears the flag for a fresh attempt.
|
|
const initialTimer = givenUpRef.current
|
|
? null
|
|
: setTimeout(fetchStats, needsWarmup ? 2000 : 0);
|
|
|
|
// Set up periodic refresh
|
|
const intervalMs = Math.max(5, refreshInterval) * 1000; // Minimum 5 seconds
|
|
if (!givenUpRef.current) {
|
|
intervalRef.current = setInterval(fetchStats, intervalMs);
|
|
}
|
|
|
|
return () => {
|
|
isMountedRef.current = false;
|
|
if (initialTimer) clearTimeout(initialTimer);
|
|
if (intervalRef.current) {
|
|
clearInterval(intervalRef.current);
|
|
intervalRef.current = null;
|
|
}
|
|
};
|
|
}, [enabled, isSupportedOs, isConnected, isVisible, refreshInterval, fetchStats]);
|
|
|
|
// Manual refresh function
|
|
const refresh = useCallback(() => {
|
|
fetchStats();
|
|
}, [fetchStats]);
|
|
|
|
return {
|
|
stats,
|
|
isLoading,
|
|
error,
|
|
refresh,
|
|
};
|
|
}
|