TG almost works

src/services/xray/client.rs

@@ -2,6 +2,7 @@ use anyhow::{Result, anyhow};
 use serde_json::Value;
 use xray_core::Client;
 use std::sync::Arc;
+use tokio::time::{timeout, Duration};
 
 // Import submodules from the same directory
 use super::stats::StatsClient;
@@ -17,17 +18,25 @@ pub struct XrayClient {
 
 #[allow(dead_code)]
 impl XrayClient {
-    /// Connect to Xray gRPC server
+    /// Connect to Xray gRPC server with timeout
     pub async fn connect(endpoint: &str) -> Result<Self> {
-        let client = Client::from_url(endpoint).await
-            .map_err(|e| anyhow!("Failed to connect to Xray at {}: {}", endpoint, e))?;
-
-        // Don't clone - we'll use &self.client when calling methods
-
-        Ok(Self {
-            endpoint: endpoint.to_string(),
-            client: Arc::new(client),
-        })
+        // Apply a 5-second timeout to the connection attempt
+        let connect_future = Client::from_url(endpoint);
+        
+        match timeout(Duration::from_secs(5), connect_future).await {
+            Ok(Ok(client)) => {
+                Ok(Self {
+                    endpoint: endpoint.to_string(),
+                    client: Arc::new(client),
+                })
+            },
+            Ok(Err(e)) => {
+                Err(anyhow!("Failed to connect to Xray at {}: {}", endpoint, e))
+            },
+            Err(_) => {
+                Err(anyhow!("Connection to Xray at {} timed out after 5 seconds", endpoint))
+            }
+        }
     }
 
     /// Get server statistics

src/services/xray/mod.rs

@@ -4,8 +4,8 @@ use uuid::Uuid;
 use std::collections::HashMap;
 use std::sync::Arc;
 use tokio::sync::RwLock;
-use tokio::time::{Duration, Instant};
-use tracing::error;
+use tokio::time::{Duration, Instant, timeout};
+use tracing::{error, warn};
 
 pub mod client;
 pub mod config;
@@ -78,15 +78,24 @@ impl XrayService {
     }
 
 
-    /// Test connection to Xray server
+    /// Test connection to Xray server with timeout
     pub async fn test_connection(&self, _server_id: Uuid, endpoint: &str) -> Result<bool> {
-        match self.get_or_create_client(endpoint).await {
-            Ok(_client) => {
-                // Instead of getting stats (which might fail), just test connection
-                // If we successfully created the client, connection is working
+        // Apply a 3-second timeout to the entire test operation
+        match timeout(Duration::from_secs(3), self.get_or_create_client(endpoint)).await {
+            Ok(Ok(_client)) => {
+                // Connection successful
                 Ok(true)
             },
-            Err(_) => Ok(false),
+            Ok(Err(e)) => {
+                // Connection failed with error
+                warn!("Failed to connect to Xray at {}: {}", endpoint, e);
+                Ok(false)
+            },
+            Err(_) => {
+                // Operation timed out
+                warn!("Connection test to Xray at {} timed out", endpoint);
+                Ok(false)
+            }
         }
     }