← HTTP Retry Client networkingmedium ready

Problem

HTTP Retry Client (Rust)

Topics: RoundTripper/Transport, retries, backoff, cancellation

Problem

Implement RetryTransport, a Transport that retries a base transport. A Transport is one round trip (Request -> Result<Response, TransportError>) — the analog of Go's http.RoundTripper. It composes: RetryTransport wraps another transport (which in tests is a mock).

pub trait Transport { fn round_trip(&self, req: Request) -> Result<Response, TransportError>; }

pub struct RetryTransport<B: Transport> { /* … */ }
impl<B: Transport> RetryTransport<B> {
    pub fn new(base: B, max_attempts: usize,
               should_retry: impl Fn(&Result<Response, TransportError>) -> bool + 'static) -> Self;
    pub fn with_backoff(self, backoff: impl Fn(usize) -> Duration + 'static) -> Self;
    pub fn with_cancel(self, cancel: Cancel) -> Self;
}

Attempt the request up to max_attempts times.
After each attempt call should_retry(&result); if it returns false, return immediately.
Between retries wait max(backoff(attempt), Retry-After); honor a server's Retry-After header when it asks for longer.
Abort the wait and return an error if the Cancel token fires.
Return the last result after attempts are exhausted.

Key concepts

Transport = RoundTripper: one method, Request -> Result<Response, _>, so transports compose; RetryTransport<B> wraps any base B: Transport.
Owned body: the Request body is an owned String, so it is inherently re-sendable across attempts — no GetBody factory needed (Go needs one because its body is a consumed stream).
Backoff + Retry-After: instant retries make an outage worse; wait between attempts, and let a server's Retry-After override when it asks for longer (retry_after is provided).
Cancellable wait: sleep_or_cancel (provided) polls the token while waiting, so a cancelled request doesn't sit blocked in a backoff sleep.

Grading

Your solution.rs is compiled together with a trusted tests.rs (which include!s it) using rustc --test. Only solution.rs is yours to edit.

Sign in to submit your solution.

Leaderboard score: lower is better, 1.0 ≈ reference

#	Name	score	ns/op	allocs

Output

No submission yet.

use std::collections::HashMap;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
use std::time::{Duration, Instant};

/// A cooperative cancellation token (stands in for the request `context`).
#[derive(Clone, Default)]
pub struct Cancel(Arc<AtomicBool>);

impl Cancel {
    pub fn new() -> Self {
        Cancel(Arc::new(AtomicBool::new(false)))
    }
    pub fn cancel(&self) {
        self.0.store(true, Ordering::SeqCst);
    }
    pub fn is_cancelled(&self) -> bool {
        self.0.load(Ordering::SeqCst)
    }
}

/// A request. `body` is owned, so it is naturally re-sendable across retries
/// (no `GetBody` dance needed as with Go's streaming bodies).
#[derive(Clone, Default)]
pub struct Request {
    pub method: String,
    pub path: String,
    pub body: Option<String>,
}

impl Request {
    pub fn new(method: &str, path: &str) -> Self {
        Request {
            method: method.to_string(),
            path: path.to_string(),
            body: None,
        }
    }
    pub fn with_body(mut self, body: &str) -> Self {
        self.body = Some(body.to_string());
        self
    }
}

/// A response with a status and headers.
#[derive(Clone)]
pub struct Response {
    pub status: u16,
    pub headers: HashMap<String, String>,
}

impl Response {
    pub fn new(status: u16) -> Self {
        Response {
            status,
            headers: HashMap::new(),
        }
    }
    pub fn with_header(mut self, key: &str, value: &str) -> Self {
        self.headers.insert(key.to_string(), value.to_string());
        self
    }
}

/// A transport error (a stand-in for a network failure).
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TransportError(pub String);

/// One round trip: send a request, get a response or an error. The analog of
/// Go's `http.RoundTripper`.
pub trait Transport {
    fn round_trip(&self, req: Request) -> Result<Response, TransportError>;
}

type ShouldRetry = Box<dyn Fn(&Result<Response, TransportError>) -> bool>;
type Backoff = Box<dyn Fn(usize) -> Duration>;

/// A `Transport` that retries a base transport up to `max_attempts` times.
pub struct RetryTransport<B: Transport> {
    base: B,
    max_attempts: usize,
    should_retry: ShouldRetry,
    backoff: Option<Backoff>,
    cancel: Cancel,
}

impl<B: Transport> RetryTransport<B> {
    pub fn new(
        base: B,
        max_attempts: usize,
        should_retry: impl Fn(&Result<Response, TransportError>) -> bool + 'static,
    ) -> Self {
        RetryTransport {
            base,
            max_attempts,
            should_retry: Box::new(should_retry),
            backoff: None,
            cancel: Cancel::new(),
        }
    }

/// Sets the per-attempt backoff (attempt index → wait before the next try).
    pub fn with_backoff(mut self, backoff: impl Fn(usize) -> Duration + 'static) -> Self {
        self.backoff = Some(Box::new(backoff));
        self
    }

/// Sets the cancellation token used to abort a backoff wait.
    pub fn with_cancel(mut self, cancel: Cancel) -> Self {
        self.cancel = cancel;
        self
    }

/// Sleeps `delay`, but returns false promptly if cancelled meanwhile.
    fn sleep_or_cancel(&self, delay: Duration) -> bool {
        let deadline = Instant::now() + delay;
        while Instant::now() < deadline {
            if self.cancel.is_cancelled() {
                return false;
            }
            let remaining = deadline.saturating_duration_since(Instant::now());
            std::thread::sleep(remaining.min(Duration::from_millis(5)));
        }
        !self.cancel.is_cancelled()
    }
}

impl<B: Transport> Transport for RetryTransport<B> {
    /// Attempt the request up to `max_attempts` times. After each attempt call
    /// `should_retry`; if it's false (or this was the last attempt) return the
    /// result. Otherwise wait `max(backoff(attempt), Retry-After)` — aborting with
    /// an error if cancelled — and try again.
    fn round_trip(&self, req: Request) -> Result<Response, TransportError> {
        // The helpers `self.base.round_trip`, `(self.should_retry)`, `self.backoff`,
        // `self.sleep_or_cancel`, and `retry_after` are all available to you.
        let _ = (&self.base, &self.max_attempts, &self.should_retry, &self.backoff, req);
        unimplemented!()
    }
}

/// Reads the `Retry-After` header in its delta-seconds form. (The HTTP-date form
/// is omitted; it would need a date parser.)
fn retry_after(resp: &Response) -> Option<Duration> {
    let secs: i64 = resp.headers.get("Retry-After")?.trim().parse().ok()?;
    if secs < 0 {
        return None;
    }
    Some(Duration::from_secs(secs as u64))
}