Complete timeout configuration implementation with documentation and validation

Co-authored-by: Alirexaa <70141416+Alirexaa@users.noreply.github.com>

Author: Copilot

Cargo_timeout_test.toml

@@ -0,0 +1,12 @@
+[package]
+name = "timeout_test"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+chico_file = { path = "chico_file" }
+chico_server = { path = "chico_server" }
+
+[[bin]]
+name = "timeout_integration"
+path = "test_integration.rs"

README.md

@@ -129,6 +129,44 @@ The `lb_policy` supports:
 
 When multiple upstreams are specified without `lb_policy`, it defaults to `round_robin`.
 
+**Proxy with Timeout Configuration:**
+```
+route /api/* {
+    proxy {
+        upstreams http://backend1:8080 http://backend2:8080
+        lb_policy round_robin
+        request_timeout 30
+        connection_timeout 10
+    }
+}
+```
+
+**Timeout Configuration Options:**
+- `request_timeout` (seconds): Maximum time to wait for a response from the upstream server (default: 30 seconds)
+- `connection_timeout` (seconds): Maximum time to wait when establishing a connection to the upstream server (default: 10 seconds)
+
+Both timeout options are optional and can be configured independently:
+```
+# Only request timeout
+proxy {
+    upstreams http://backend:8080
+    request_timeout 15
+}
+
+# Only connection timeout  
+proxy {
+    upstreams http://backend:8080
+    connection_timeout 5
+}
+
+# Both timeouts
+proxy {
+    upstreams http://backend:8080
+    request_timeout 25
+    connection_timeout 8
+}
+```
+
 ### Testing
 
 To run the tests, use the following command:

chico_file/src/lib.rs

@@ -18,6 +18,10 @@ use crate::types::Upstream;
 
 pub mod types;
 
+// Type aliases for complex return types to satisfy clippy
+type ProxyBlockContentsResult<'a> = IResult<&'a str, (Vec<Upstream>, Option<String>, Option<u64>, Option<u64>)>;
+type ProxyOptionalFieldsResult<'a> = IResult<&'a str, (Option<String>, Option<u64>, Option<u64>)>;
+
 /// Convert nom parsing errors into user-friendly error messages
 fn format_parse_error(input: &str, error: nom::Err<Error<&str>>) -> String {
     match error {
@@ -1047,7 +1051,7 @@ fn parse_proxy_block(input: &str) -> IResult<&str, types::Handler> {
 }
 
 // Parses the contents inside the proxy block
-fn parse_proxy_block_contents(input: &str) -> IResult<&str, (Vec<Upstream>, Option<String>, Option<u64>, Option<u64>)> {
+fn parse_proxy_block_contents(input: &str) -> ProxyBlockContentsResult<'_> {
     let (input, _) = multispace0(input)?;
 
     // Allow comments before upstreams
@@ -1069,7 +1073,7 @@ fn parse_proxy_block_contents(input: &str) -> IResult<&str, (Vec<Upstream>, Opti
 }
 
 // Parse optional fields like lb_policy, request_timeout, connection_timeout in any order
-fn parse_proxy_optional_fields(input: &str) -> IResult<&str, (Option<String>, Option<u64>, Option<u64>)> {
+fn parse_proxy_optional_fields(input: &str) -> ProxyOptionalFieldsResult<'_> {
     let mut remaining = input;
     let mut lb_policy = None;
     let mut request_timeout = None;

chico_server/src/plan_test.rs

@@ -0,0 +1,51 @@
+// Test server plan creation with timeout configuration
+
+mod plan;
+mod handlers;
+mod load_balance;
+
+use plan::{ServerPlan, RoutePlan};
+
+fn main() {
+    println!("=== Testing ServerPlan creation with timeout configuration ===");
+    
+    let config_text = "localhost { route /api/* { proxy { upstreams http://127.0.0.1:8080 request_timeout 20 connection_timeout 8 } } }";
+    
+    match chico_file::parse_config(config_text) {
+        Ok((_, config)) => {
+            println!("✓ Config parsed successfully");
+            
+            // Test ServerPlan creation (this tests the plan.rs integration)
+            let server_plan = ServerPlan::from_config(&config);
+            println!("✓ ServerPlan created successfully");
+            
+            // Find the route and verify it was created properly
+            if let Some(vhost_plan) = server_plan.find_virtual_host("localhost", 80) {
+                println!("✓ Virtual host found");
+                
+                if let Some(route_plan) = vhost_plan.find_route("/api/test") {
+                    println!("✓ Route found and matches");
+                    
+                    match route_plan {
+                        RoutePlan::ReverseProxy(_handler) => {
+                            println!("✓ ReverseProxyHandler created successfully!");
+                            println!("✓ Handler should have timeout configuration applied");
+                        }
+                        _ => {
+                            println!("✗ Expected ReverseProxyHandler, got different handler type");
+                        }
+                    }
+                } else {
+                    println!("✗ Route not found");
+                }
+            } else {
+                println!("✗ Virtual host not found");
+            }
+        }
+        Err(e) => {
+            println!("✗ Parse error: {}", e);
+        }
+    }
+    
+    println!("\n🎉 ServerPlan integration test complete!");
+}

chico_server/src/timeout_test.rs

@@ -0,0 +1,87 @@
+// Manual test to validate the timeout configuration functionality
+
+fn main() {
+    // Test 1: Basic proxy parsing (should work)
+    println!("=== Test 1: Basic proxy parsing ===");
+    let simple_config = "localhost { route /test/* { proxy http://localhost:8080 } }";
+    
+    match chico_file::parse_config(simple_config) {
+        Ok((remaining, config)) => {
+            println!("✓ Simple proxy config parsed successfully!");
+            println!("  Remaining: '{}'", remaining);
+            
+            let route = &config.virtual_hosts[0].routes[0];
+            match &route.handler {
+                chico_file::types::Handler::Proxy(proxy_config) => {
+                    println!("  Request timeout: {:?}", proxy_config.request_timeout);
+                    println!("  Connection timeout: {:?}", proxy_config.connection_timeout);
+                    println!("  ✓ Simple proxy test passed");
+                }
+                _ => println!("  ✗ Not a proxy handler"),
+            }
+        }
+        Err(e) => {
+            println!("  ✗ Parse error: {}", e);
+        }
+    }
+    
+    // Test 2: Proxy with timeouts
+    println!("\n=== Test 2: Proxy with timeouts ===");
+    let timeout_config = "localhost { route /api/* { proxy { upstreams http://localhost:8080 request_timeout 25 connection_timeout 10 } } }";
+    
+    match chico_file::parse_config(timeout_config) {
+        Ok((remaining, config)) => {
+            println!("✓ Timeout proxy config parsed successfully!");
+            println!("  Remaining: '{}'", remaining);
+            
+            let route = &config.virtual_hosts[0].routes[0];
+            match &route.handler {
+                chico_file::types::Handler::Proxy(proxy_config) => {
+                    println!("  Request timeout: {:?}", proxy_config.request_timeout);
+                    println!("  Connection timeout: {:?}", proxy_config.connection_timeout);
+                    
+                    if proxy_config.request_timeout == Some(25) && proxy_config.connection_timeout == Some(10) {
+                        println!("  ✓ Timeout values parsed correctly!");
+                    } else {
+                        println!("  ✗ Timeout values incorrect");
+                    }
+                }
+                _ => println!("  ✗ Not a proxy handler"),
+            }
+        }
+        Err(e) => {
+            println!("  ✗ Parse error: {}", e);
+        }
+    }
+    
+    // Test 3: Proxy with only request timeout
+    println!("\n=== Test 3: Proxy with partial timeouts ===");
+    let partial_config = "localhost { route /partial/* { proxy { upstreams http://localhost:8080 request_timeout 15 } } }";
+    
+    match chico_file::parse_config(partial_config) {
+        Ok((remaining, config)) => {
+            println!("✓ Partial timeout config parsed successfully!");
+            println!("  Remaining: '{}'", remaining);
+            
+            let route = &config.virtual_hosts[0].routes[0];
+            match &route.handler {
+                chico_file::types::Handler::Proxy(proxy_config) => {
+                    println!("  Request timeout: {:?}", proxy_config.request_timeout);
+                    println!("  Connection timeout: {:?}", proxy_config.connection_timeout);
+                    
+                    if proxy_config.request_timeout == Some(15) && proxy_config.connection_timeout.is_none() {
+                        println!("  ✓ Partial timeout configuration correct!");
+                    } else {
+                        println!("  ✗ Partial timeout values incorrect");
+                    }
+                }
+                _ => println!("  ✗ Not a proxy handler"),
+            }
+        }
+        Err(e) => {
+            println!("  ✗ Parse error: {}", e);
+        }
+    }
+    
+    println!("\n🎉 Manual timeout configuration tests complete!");
+}