Struct TimeoutPolicy 

pub struct TimeoutPolicy { /* private fields */ }

A policy that enforces a maximum duration for operations.

If the operation doesn’t complete within the timeout, it is cancelled and DoOverError::Timeout is returned.

Examples

use do_over::{policy::Policy, timeout::TimeoutPolicy, error::DoOverError};
use std::time::Duration;

let policy = TimeoutPolicy::new(Duration::from_secs(10));

let result: Result<String, DoOverError<String>> = policy.execute(|| async {
    // Long-running operation
    Ok("done".to_string())
}).await;

Implementations

impl TimeoutPolicy

pub fn new(timeout: Duration) -> Self

Create a new timeout policy.

Arguments

• timeout - Maximum duration to wait for the operation

Examples

use do_over::timeout::TimeoutPolicy;
use std::time::Duration;

// 5 second timeout
let policy = TimeoutPolicy::new(Duration::from_secs(5));

Examples found in repository

examples/comprehensive.rs (line 58)

fn create_inventory_policy() -> InventoryPolicy {
    Wrap::new(
        RateLimiter::new(3, Duration::from_secs(1)), // 3 requests per second
        Wrap::new(
            RetryPolicy::fixed(2, Duration::from_millis(100)),
            TimeoutPolicy::new(Duration::from_millis(500)),
        ),
    )
}

fn create_payment_policy() -> PaymentPolicy {
    Wrap::new(
        CircuitBreaker::new(3, Duration::from_secs(5)), // Opens after 3 failures
        Wrap::new(
            RetryPolicy::fixed(2, Duration::from_millis(200)),
            TimeoutPolicy::new(Duration::from_secs(1)),
        ),
    )
}

fn create_notification_policy() -> NotificationPolicy {
    Wrap::new(
        Hedge::new(Duration::from_millis(100)), // Start hedge after 100ms
        TimeoutPolicy::new(Duration::from_millis(500)),
    )
}

examples/http_service.rs (line 14)

async fn main() {
    let policy = Wrap::new(
        RetryPolicy::fixed(2, Duration::from_millis(50)),
        TimeoutPolicy::new(Duration::from_secs(1)),
    );

    let app = Router::new().route(
        "/",
        get(|| async move {
            let result: Result<&str, DoOverError<()>> =
                policy.execute(|| async { Ok("hello from do-over") }).await;
            result.unwrap()
        }),
    );

    println!("Starting server on http://0.0.0.0:3000");
    let listener = TcpListener::bind("0.0.0.0:3000").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

examples/timeout.rs (line 31)

async fn fast_operation_example() {
    println!("📌 Scenario 1: Fast Operation (completes within timeout)");
    println!("   Configuration: timeout=500ms, operation_time=100ms\n");

    let policy = TimeoutPolicy::new(Duration::from_millis(500));
    let start = Instant::now();

    let result: Result<String, DoOverError<String>> = policy
        .execute(|| async {
            println!("   → Operation started...");
            tokio::time::sleep(Duration::from_millis(100)).await;
            println!("   → Operation completed!");
            Ok("Fast operation result".to_string())
        })
        .await;

    let elapsed = start.elapsed();
    println!("\n   Result: {:?}", result.unwrap());
    println!("   Elapsed: {:?} (well under 500ms timeout)", elapsed);
}

async fn slow_operation_example() {
    println!("📌 Scenario 2: Slow Operation (exceeds timeout)");
    println!("   Configuration: timeout=200ms, operation_time=500ms\n");

    let policy = TimeoutPolicy::new(Duration::from_millis(200));
    let start = Instant::now();

    let result: Result<String, DoOverError<String>> = policy
        .execute(|| async {
            println!("   → Operation started (will take 500ms)...");
            tokio::time::sleep(Duration::from_millis(500)).await;
            // This line should not be reached
            println!("   → This should not print!");
            Ok("Slow operation result".to_string())
        })
        .await;

    let elapsed = start.elapsed();

    match result {
        Err(DoOverError::Timeout) => {
            println!("   → Operation cancelled due to timeout!");
            println!("\n   Result: DoOverError::Timeout");
        }
        _ => println!("   Unexpected result: {:?}", result),
    }

    println!("   Elapsed: {:?} (stopped at ~200ms timeout)", elapsed);
    println!("\n   💡 The operation was cancelled - no resources wasted!");
}

async fn edge_case_example() {
    println!("📌 Scenario 3: Edge Case (operation completes just in time)");
    println!("   Configuration: timeout=300ms, operation_time=250ms\n");

    let policy = TimeoutPolicy::new(Duration::from_millis(300));
    let start = Instant::now();

    let result: Result<String, DoOverError<String>> = policy
        .execute(|| async {
            println!("   → Operation started (will take 250ms)...");
            tokio::time::sleep(Duration::from_millis(250)).await;
            println!("   → Operation completed just in time!");
            Ok("Completed with 50ms to spare".to_string())
        })
        .await;

    let elapsed = start.elapsed();

    match result {
        Ok(msg) => {
            println!("\n   Result: ✅ {}", msg);
        }
        Err(DoOverError::Timeout) => {
            println!("\n   Result: ❌ Timeout (race condition)");
        }
        Err(e) => {
            println!("\n   Result: {:?}", e);
        }
    }

    println!("   Elapsed: {:?}", elapsed);
}

examples/composition.rs (line 44)

async fn pattern1_retry_timeout() {
    println!("📌 Pattern 1: Retry wrapping Timeout");
    println!("   Wrap::new(Retry(3, 100ms), Timeout(200ms))");
    println!("   → Each retry attempt gets its own 200ms timeout\n");

    let policy = Wrap::new(
        RetryPolicy::fixed(3, Duration::from_millis(100)),
        TimeoutPolicy::new(Duration::from_millis(200)),
    );

    let attempt_count = Arc::new(AtomicUsize::new(0));
    let start = Instant::now();

    // Scenario: First 2 attempts timeout, third succeeds quickly
    let result: Result<String, DoOverError<String>> = {
        let ac = Arc::clone(&attempt_count);
        policy
            .execute(|| {
                let count = Arc::clone(&ac);
                async move {
                    let attempt = count.fetch_add(1, Ordering::SeqCst) + 1;
                    let elapsed = start.elapsed().as_millis();
                    println!(
                        "   [+{:>4}ms] Attempt {}: Started",
                        elapsed, attempt
                    );

                    if attempt < 3 {
                        // First two attempts are slow - will timeout
                        println!(
                            "   [+{:>4}ms] Attempt {}: Processing slowly (will timeout)...",
                            elapsed, attempt
                        );
                        tokio::time::sleep(Duration::from_millis(500)).await;
                        Ok("Should not reach here".to_string())
                    } else {
                        // Third attempt is fast
                        tokio::time::sleep(Duration::from_millis(50)).await;
                        let elapsed = start.elapsed().as_millis();
                        println!(
                            "   [+{:>4}ms] Attempt {}: ✅ Completed quickly!",
                            elapsed, attempt
                        );
                        Ok("Success on attempt 3".to_string())
                    }
                }
            })
            .await
    };

    let total_time = start.elapsed().as_millis();
    println!("\n   Result: {:?}", result.unwrap());
    println!("   Total time: {}ms", total_time);
    println!("   Total attempts: {}", attempt_count.load(Ordering::SeqCst));
    println!("\n   💡 Each attempt had its own timeout; operation succeeded on 3rd try");
}

async fn pattern2_circuit_retry() {
    println!("📌 Pattern 2: CircuitBreaker wrapping Retry");
    println!("   Wrap::new(CircuitBreaker(3, 1s), Retry(2, 50ms))");
    println!("   → Retries happen inside the circuit breaker\n");

    let policy = Wrap::new(
        CircuitBreaker::new(3, Duration::from_secs(1)),
        RetryPolicy::fixed(2, Duration::from_millis(50)),
    );

    let failure_count = Arc::new(AtomicUsize::new(0));
    let start = Instant::now();

    // Make several calls that fail to open the circuit
    println!("   Phase 1: Failing calls to open circuit");
    for i in 1..=4 {
        let fc = Arc::clone(&failure_count);
        let s = start;
        let result: Result<String, DoOverError<String>> = policy
            .execute(|| {
                let count = Arc::clone(&fc);
                async move {
                    count.fetch_add(1, Ordering::SeqCst);
                    let elapsed = s.elapsed().as_millis();
                    println!(
                        "   [+{:>4}ms] Call {}: Inner operation failing...",
                        elapsed, i
                    );
                    Err(DoOverError::Inner(format!("Service error")))
                }
            })
            .await;

        let elapsed = start.elapsed().as_millis();
        match &result {
            Err(DoOverError::Inner(_)) => {
                println!(
                    "   [+{:>4}ms] Call {}: ❌ Failed after retries",
                    elapsed, i
                );
            }
            Err(DoOverError::CircuitOpen) => {
                println!(
                    "   [+{:>4}ms] Call {}: 🚫 Circuit is OPEN",
                    elapsed, i
                );
            }
            _ => {}
        }
    }

    let inner_calls = failure_count.load(Ordering::SeqCst);
    println!("\n   Summary:");
    println!("   - Inner operation calls: {} (includes retries)", inner_calls);
    println!("   - Circuit opened after threshold reached");
    println!("\n   💡 Retries happened inside circuit breaker; failures accumulated to open circuit");
}

async fn pattern3_full_stack() {
    println!("📌 Pattern 3: Full Resilience Stack");
    println!("   Bulkhead(2) → Retry(2, 100ms) → Timeout(500ms)");
    println!("   Recommended ordering for production systems\n");

    // Note: Using Bulkhead + Retry + Timeout for this example to avoid
    // CircuitBreaker clone issues in concurrent async context
    let policy = Arc::new(Wrap::new(
        Bulkhead::new(2),
        Wrap::new(
            RetryPolicy::fixed(2, Duration::from_millis(100)),
            TimeoutPolicy::new(Duration::from_millis(500)),
        ),
    ));

    let call_count = Arc::new(AtomicUsize::new(0));
    let start = Instant::now();

    println!("   Launching 4 concurrent requests (bulkhead limit is 2)...\n");

    let mut handles = vec![];
    for i in 1..=4 {
        let p = Arc::clone(&policy);
        let cc = Arc::clone(&call_count);
        let s = start;

        let handle = tokio::spawn(async move {
            let result: Result<String, DoOverError<String>> = p
                .execute(|| {
                    let count = Arc::clone(&cc);
                    async move {
                        let call = count.fetch_add(1, Ordering::SeqCst) + 1;
                        let elapsed = s.elapsed().as_millis();
                        println!(
                            "   [+{:>4}ms] Request {}, call {}: Processing...",
                            elapsed, i, call
                        );
                        tokio::time::sleep(Duration::from_millis(200)).await;
                        let elapsed = s.elapsed().as_millis();
                        println!(
                            "   [+{:>4}ms] Request {}, call {}: ✅ Done",
                            elapsed, i, call
                        );
                        Ok(format!("Response {}", i))
                    }
                })
                .await;

            let elapsed = s.elapsed().as_millis();
            match &result {
                Ok(msg) => println!("   [+{:>4}ms] Request {}: ✅ {}", elapsed, i, msg),
                Err(DoOverError::BulkheadFull) => {
                    println!("   [+{:>4}ms] Request {}: 🚫 Rejected by bulkhead", elapsed, i)
                }
                Err(e) => println!("   [+{:>4}ms] Request {}: ❌ {:?}", elapsed, i, e),
            }
        });
        handles.push(handle);

        tokio::time::sleep(Duration::from_millis(10)).await;
    }

    for handle in handles {
        handle.await.unwrap();
    }

    let total_time = start.elapsed().as_millis();
    let total_calls = call_count.load(Ordering::SeqCst);

    println!("\n   Summary:");
    println!("   - Total inner operation calls: {}", total_calls);
    println!("   - Total time: {}ms", total_time);
    println!("\n   Policy execution order:");
    println!("   1. Bulkhead: Limits to 2 concurrent executions");
    println!("   2. Retry: Retries transient failures");
    println!("   3. Timeout: Each attempt bounded to 500ms");
}

Trait Implementations

impl Clone for TimeoutPolicy

fn clone(&self) -> TimeoutPolicy

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<E> Policy<DoOverError<E>> for TimeoutPolicy

where E: Send + Sync,

fn execute<'life0, 'async_trait, F, Fut, T>( &'life0 self, f: F, ) -> Pin<Box<dyn Future<Output = Result<T, DoOverError<E>>> + Send + 'async_trait>>

where F: Fn() -> Fut + Send + Sync + 'async_trait, Fut: Future<Output = Result<T, DoOverError<E>>> + Send + 'async_trait, T: Send + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Execute an async operation with this policy’s resilience behavior.