Use ping package for latency checks; add initial + scheduled tests, update tests and deps

- Replace @network-utils/tcp-ping with the "ping" package and switch to ping.promise.probe API
- Remove per-host port handling and adjust result parsing (use result.alive/result.time)
- Reduce ping timeout (5000ms -> 500ms) for faster checks
- Run an initial latency test on startup and schedule periodic tests every 15 minutes
- Update tests to mock the new ping API and adjust expectations
- Add "ping" to package.json dependencies

Author: essinghigh

radius-proxy/lib/radius-host-selector.ts

@@ -1,4 +1,4 @@
-import { ping } from "@network-utils/tcp-ping"
+import * as ping from 'ping'
 import { config } from "@/lib/config"
 import { warn, info, debug } from "@/lib/log"
 
@@ -13,9 +13,23 @@ class RadiusHostSelector {
     private hostStatuses: Map<string, HostStatus> = new Map()
     private lastTestTime = 0
     private testInterval = 15 * 60 * 1000 // 15 minutes in milliseconds
-    private testTimeout = 5000 // 5 seconds in milliseconds
+    private testTimeout = 500 // 500 milliseconds
     private isTestingInProgress = false
 
+    constructor() {
+        // Run initial latency test on startup to avoid waiting during first login
+        this.runLatencyTests().catch(error => {
+            warn(`[radius-host-selector] Initial latency test failed:`, error)
+        })
+
+        // Run latency tests every 15 minutes automatically
+        setInterval(() => {
+            this.runLatencyTests().catch(error => {
+                warn(`[radius-host-selector] Scheduled latency test failed:`, error)
+            })
+        }, this.testInterval)
+    }
+
     private getHostsFromConfig(): string[] {
         const radiusHost = config.RADIUS_HOST
         if (Array.isArray(radiusHost)) {
@@ -27,29 +41,26 @@ class RadiusHostSelector {
         return ['127.0.0.1'] // fallback
     }
 
-    private async testHostLatency(host: string, port: number): Promise<{ latency: number | null, isDown: boolean }> {
+    private async testHostLatency(host: string): Promise<{ latency: number | null, isDown: boolean }> {
         try {
-            debug(`[radius-host-selector] Testing latency for ${host}:${port}`)
+            debug(`[radius-host-selector] Testing latency for ${host}`)
 
-            const result = await ping({
-                address: host,
-                port: port,
-                timeout: this.testTimeout,
-                attempts: 1
+            const result = await ping.promise.probe(host, {
+                timeout: this.testTimeout / 1000 // convert to seconds
             })
 
             debug(`[radius-host-selector] Ping result for ${host}:`, result)
 
-            if (result.errors && result.errors.length > 0) {
-                debug(`[radius-host-selector] Host ${host}:${port} is down - ${result.errors[0].error.message}`)
+            if (!result.alive) {
+                debug(`[radius-host-selector] Host ${host} is down`)
                 return { latency: null, isDown: true }
             }
 
-            const latency = result.averageLatency
-            debug(`[radius-host-selector] Host ${host}:${port} latency: ${latency}ms`)
+            const latency = typeof result.time === 'number' ? result.time : null
+            debug(`[radius-host-selector] Host ${host} latency: ${latency}ms`)
             return { latency, isDown: false }
         } catch (error) {
-            warn(`[radius-host-selector] Error testing ${host}:${port}:`, error)
+            warn(`[radius-host-selector] Error testing ${host}:`, error)
             return { latency: null, isDown: true }
         }
     }
@@ -68,7 +79,6 @@ class RadiusHostSelector {
         try {
             this.isTestingInProgress = true
             const hosts = this.getHostsFromConfig()
-            const port = config.RADIUS_PORT || 1812
             const now = Date.now()
 
             info(`[radius-host-selector] Testing latency for ${hosts.length} RADIUS hosts`)
@@ -77,7 +87,7 @@ class RadiusHostSelector {
             // Test all hosts in parallel
             const testPromises = hosts.map(async (host) => {
                 debug(`[radius-host-selector] Starting test for ${host}`)
-                const { latency, isDown } = await this.testHostLatency(host, port)
+                const { latency, isDown } = await this.testHostLatency(host)
                 debug(`[radius-host-selector] Test result for ${host}: latency=${latency}, isDown=${isDown}`)
 
                 const status: HostStatus = {

radius-proxy/package.json

@@ -20,6 +20,7 @@
     "lucide-react": "^0.544.0",
     "next": "15.5.4",
     "next-themes": "^0.4.6",
+    "ping": "^1.0.0",
     "react": "19.1.0",
     "react-dom": "19.1.0",
     "sonner": "^2.0.7",

radius-proxy/tests/radius-host-selector.test.ts

@@ -1,60 +1,43 @@
 import { expect, test, describe, beforeEach, mock } from "bun:test";
 import { config, _invalidateConfigCache } from "@/lib/config";
 
-interface PingOptions {
-    address: string;
-    port?: number;
-    timeout?: number;
-    attempts?: number;
-}
-
 interface HostStatus {
-    host: string;
-    latency: number | null;
-    isDown: boolean;
-    lastChecked: number;
+    host: string
+    latency: number | null
+    isDown: boolean
+    lastChecked: number
 }
 
-// Mock the tcp-ping module to simulate different latency scenarios
-mock.module("@network-utils/tcp-ping", () => ({
-    ping: async (options: PingOptions) => {
-        const host = options.address;
-
-        // Simulate different latency scenarios
-        if (host === "192.168.0.191") {
-            return {
-                averageLatency: 20,
-                errors: [],
-                maximumLatency: 25,
-                minimumLatency: 15,
-                options
-            };
-        } else if (host === "192.168.0.192") {
-            return {
-                averageLatency: 30,
-                errors: [],
-                maximumLatency: 35,
-                minimumLatency: 25,
-                options
-            };
-        } else if (host === "192.168.0.193") {
-            // Simulate host down
-            return {
-                averageLatency: null,
-                errors: [{ attempt: 1, error: new Error("Request timeout") }],
-                maximumLatency: 0,
-                minimumLatency: null,
-                options
-            };
-        } else {
-            // Default case for other hosts
-            return {
-                averageLatency: 50,
-                errors: [],
-                maximumLatency: 55,
-                minimumLatency: 45,
-                options
-            };
+// Mock the ping module to simulate different latency scenarios
+mock.module('ping', () => ({
+    default: {
+        promise: {
+            probe: async (host: string) => {
+                // Simulate different latency scenarios
+                if (host === "192.168.0.191") {
+                    return {
+                        alive: true,
+                        time: 20
+                    };
+                } else if (host === "192.168.0.192") {
+                    return {
+                        alive: true,
+                        time: 30
+                    };
+                } else if (host === "192.168.0.193") {
+                    // Simulate host down
+                    return {
+                        alive: false,
+                        time: 'unknown'
+                    };
+                } else {
+                    // Default case for other hosts
+                    return {
+                        alive: true,
+                        time: 50
+                    };
+                }
+            }
         }
     }
 }));
@@ -130,33 +113,26 @@ describe("RADIUS Host Selector", () => {
     });
 
     test("should demonstrate host selection logic with mocked responses", async () => {
-        // Test the tcp-ping mock directly to verify it's working as expected
-        const { ping } = await import("@network-utils/tcp-ping");
+        // Test the ping mock directly to verify it's working as expected
+        const ping = await import('ping');
 
         // Test various scenarios to validate our mock logic
         const scenarios = [
             // Normal latency responses
-            { host: "192.168.0.191", expectedLatency: 20, expectedDown: false, description: "fastest host" },
-            { host: "192.168.0.192", expectedLatency: 30, expectedDown: false, description: "slower host" },
-            { host: "192.168.0.193", expectedLatency: null, expectedDown: true, description: "down host" },
-            { host: "10.0.0.100", expectedLatency: 50, expectedDown: false, description: "default case" }
+            { host: "192.168.0.191", expectedTime: 20, expectedAlive: true, description: "fastest host" },
+            { host: "192.168.0.192", expectedTime: 30, expectedAlive: true, description: "slower host" },
+            { host: "192.168.0.193", expectedTime: 'unknown', expectedAlive: false, description: "down host" },
+            { host: "10.0.0.100", expectedTime: 50, expectedAlive: true, description: "default case" }
         ];
 
         for (const scenario of scenarios) {
-            const result = await ping({
-                address: scenario.host,
-                port: 1812,
-                timeout: 5000,
-                attempts: 1
+            const result = await ping.default.promise.probe(scenario.host, {
+                timeout: 5
             });
 
-            if (scenario.expectedDown) {
-                expect(result.averageLatency).toBeNull();
-                expect(result.errors.length).toBeGreaterThan(0);
-            } else {
-                expect(result.averageLatency).toBe(scenario.expectedLatency as number);
-                expect(result.errors).toEqual([]);
-            }
+            expect(result.alive).toBe(scenario.expectedAlive);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (expect(result.time) as any).toEqual(scenario.expectedTime);
         }
     });
 
@@ -220,35 +196,29 @@ describe("RADIUS Host Selector", () => {
 
     test("should select second host when it has lowest latency", async () => {
         // Mock where the SECOND host has the lowest latency, not the first
-        mock.module("@network-utils/tcp-ping", () => ({
-            ping: async (options: PingOptions) => {
-                const host = options.address;
-                if (host === "192.168.0.191") {
-                    return {
-                        averageLatency: 50, // First host is slowest
-                        errors: [],
-                        maximumLatency: 55,
-                        minimumLatency: 45,
-                        options
-                    };
-                } else if (host === "192.168.0.192") {
-                    return {
-                        averageLatency: 15, // Second host is fastest
-                        errors: [],
-                        maximumLatency: 20,
-                        minimumLatency: 10,
-                        options
-                    };
-                } else if (host === "192.168.0.193") {
-                    return {
-                        averageLatency: 30, // Third host is medium
-                        errors: [],
-                        maximumLatency: 35,
-                        minimumLatency: 25,
-                        options
-                    };
+        mock.module('ping', () => ({
+            default: {
+                promise: {
+                    probe: async (host: string) => {
+                        if (host === "192.168.0.191") {
+                            return {
+                                alive: true,
+                                time: 50 // First host is slowest
+                            };
+                        } else if (host === "192.168.0.192") {
+                            return {
+                                alive: true,
+                                time: 15 // Second host is fastest
+                            };
+                        } else if (host === "192.168.0.193") {
+                            return {
+                                alive: true,
+                                time: 30 // Third host is medium
+                            };
+                        }
+                        return { alive: true, time: 100 };
+                    }
                 }
-                return { averageLatency: 100, errors: [], maximumLatency: 100, minimumLatency: 100, options };
             }
         }));
 
@@ -274,35 +244,29 @@ describe("RADIUS Host Selector", () => {
 
     test("should select third host when it has lowest latency", async () => {
         // Mock where the THIRD host has the lowest latency
-        mock.module("@network-utils/tcp-ping", () => ({
-            ping: async (options: PingOptions) => {
-                const host = options.address;
-                if (host === "192.168.0.191") {
-                    return {
-                        averageLatency: 45, // First host is medium
-                        errors: [],
-                        maximumLatency: 50,
-                        minimumLatency: 40,
-                        options
-                    };
-                } else if (host === "192.168.0.192") {
-                    return {
-                        averageLatency: 60, // Second host is slowest
-                        errors: [],
-                        maximumLatency: 65,
-                        minimumLatency: 55,
-                        options
-                    };
-                } else if (host === "192.168.0.193") {
-                    return {
-                        averageLatency: 12, // Third host is fastest
-                        errors: [],
-                        maximumLatency: 15,
-                        minimumLatency: 10,
-                        options
-                    };
+        mock.module('ping', () => ({
+            default: {
+                promise: {
+                    probe: async (host: string) => {
+                        if (host === "192.168.0.191") {
+                            return {
+                                alive: true,
+                                time: 45 // First host is medium
+                            };
+                        } else if (host === "192.168.0.192") {
+                            return {
+                                alive: true,
+                                time: 60 // Second host is slowest
+                            };
+                        } else if (host === "192.168.0.193") {
+                            return {
+                                alive: true,
+                                time: 12 // Third host is fastest
+                            };
+                        }
+                        return { alive: true, time: 100 };
+                    }
                 }
-                return { averageLatency: 100, errors: [], maximumLatency: 100, minimumLatency: 100, options };
             }
         }));