Skip to main content

yaiko_core/
http_client.rs

1//! Outbound HTTP request policy and client helpers.
2
3use crate::TraceContext;
4use hyper::{Body, Client, Method, Request as HyperRequest, StatusCode, Uri};
5use std::collections::BTreeMap;
6use std::time::Duration;
7
8#[derive(Debug, Clone, PartialEq, Eq)]
9pub struct HttpRetryPolicy {
10    pub max_attempts: u32,
11    pub backoff: Duration,
12    pub retry_statuses: Vec<StatusCode>,
13}
14
15impl Default for HttpRetryPolicy {
16    fn default() -> Self {
17        Self {
18            max_attempts: 3,
19            backoff: Duration::from_millis(100),
20            retry_statuses: vec![
21                StatusCode::REQUEST_TIMEOUT,
22                StatusCode::TOO_MANY_REQUESTS,
23                StatusCode::BAD_GATEWAY,
24                StatusCode::SERVICE_UNAVAILABLE,
25                StatusCode::GATEWAY_TIMEOUT,
26            ],
27        }
28    }
29}
30
31impl HttpRetryPolicy {
32    pub fn should_retry(&self, attempt: u32, status: Option<StatusCode>) -> bool {
33        attempt + 1 < self.max_attempts
34            && status
35                .map(|status| self.retry_statuses.contains(&status))
36                .unwrap_or(true)
37    }
38    pub fn delay(&self, attempt: u32) -> Duration {
39        self.backoff.saturating_mul(2u32.saturating_pow(attempt))
40    }
41}
42
43#[derive(Debug, Clone)]
44pub struct HttpRequestSpec {
45    pub method: Method,
46    pub uri: Uri,
47    pub headers: BTreeMap<String, String>,
48    pub body: Vec<u8>,
49    pub timeout: Duration,
50    pub retry: HttpRetryPolicy,
51}
52
53impl HttpRequestSpec {
54    pub fn new(method: Method, uri: Uri) -> Self {
55        Self {
56            method,
57            uri,
58            headers: BTreeMap::new(),
59            body: Vec::new(),
60            timeout: Duration::from_secs(10),
61            retry: HttpRetryPolicy::default(),
62        }
63    }
64    pub fn header(mut self, name: impl Into<String>, value: impl Into<String>) -> Self {
65        self.headers.insert(name.into(), value.into());
66        self
67    }
68    pub fn body(mut self, body: impl Into<Vec<u8>>) -> Self {
69        self.body = body.into();
70        self
71    }
72    pub fn timeout(mut self, timeout: Duration) -> Self {
73        self.timeout = timeout;
74        self
75    }
76    pub fn retry(mut self, retry: HttpRetryPolicy) -> Self {
77        self.retry = retry;
78        self
79    }
80    pub fn with_trace(mut self, context: &TraceContext) -> Self {
81        for (name, value) in context.to_headers() {
82            self.headers.insert(name, value);
83        }
84        self
85    }
86}
87
88#[derive(Debug, Clone, PartialEq, Eq)]
89pub struct HttpResponse {
90    pub status: StatusCode,
91    pub headers: BTreeMap<String, String>,
92    pub body: Vec<u8>,
93}
94
95#[derive(Debug, Clone, PartialEq, Eq)]
96pub enum HttpClientError {
97    InvalidRequest(String),
98    Timeout,
99    Transport(String),
100    Response(StatusCode),
101}
102
103#[derive(Clone)]
104pub struct OutboundHttpClient {
105    client: Client<hyper::client::HttpConnector, Body>,
106}
107
108impl OutboundHttpClient {
109    pub fn new() -> Self {
110        Self {
111            client: Client::new(),
112        }
113    }
114
115    pub async fn execute(&self, spec: HttpRequestSpec) -> Result<HttpResponse, HttpClientError> {
116        let mut builder = HyperRequest::builder().method(spec.method).uri(spec.uri);
117        for (name, value) in &spec.headers {
118            builder = builder.header(name, value);
119        }
120        let request = builder
121            .body(Body::from(spec.body))
122            .map_err(|error| HttpClientError::InvalidRequest(error.to_string()))?;
123        let response = tokio::time::timeout(spec.timeout, self.client.request(request))
124            .await
125            .map_err(|_| HttpClientError::Timeout)?
126            .map_err(|error| HttpClientError::Transport(error.to_string()))?;
127        let status = response.status();
128        let headers = response
129            .headers()
130            .iter()
131            .filter_map(|(name, value)| {
132                value
133                    .to_str()
134                    .ok()
135                    .map(|value| (name.as_str().to_string(), value.to_string()))
136            })
137            .collect();
138        let body = hyper::body::to_bytes(response.into_body())
139            .await
140            .map_err(|error| HttpClientError::Transport(error.to_string()))?
141            .to_vec();
142        if !status.is_success() {
143            return Err(HttpClientError::Response(status));
144        }
145        Ok(HttpResponse {
146            status,
147            headers,
148            body,
149        })
150    }
151}
152
153impl Default for OutboundHttpClient {
154    fn default() -> Self {
155        Self::new()
156    }
157}
158
159#[cfg(test)]
160mod tests {
161    use super::*;
162
163    #[test]
164    fn builds_typed_spec_with_trace_propagation() {
165        let context = TraceContext::new(true);
166        let spec = HttpRequestSpec::new(Method::POST, "http://example.com/hook".parse().unwrap())
167            .body("payload")
168            .with_trace(&context);
169        assert_eq!(
170            spec.headers["traceparent"],
171            context.to_headers()["traceparent"]
172        );
173        assert_eq!(spec.body, b"payload");
174    }
175
176    #[test]
177    fn classifies_retryable_statuses_and_exponential_delays() {
178        let policy = HttpRetryPolicy::default();
179        assert!(policy.should_retry(0, Some(StatusCode::SERVICE_UNAVAILABLE)));
180        assert!(!policy.should_retry(2, Some(StatusCode::SERVICE_UNAVAILABLE)));
181        assert_eq!(policy.delay(2), Duration::from_millis(400));
182        assert!(!policy.should_retry(0, Some(StatusCode::BAD_REQUEST)));
183    }
184
185    #[tokio::test]
186    async fn reports_invalid_requests_before_transport() {
187        let client = OutboundHttpClient::new();
188        let spec = HttpRequestSpec::new(
189            Method::GET,
190            "http://[invalid"
191                .parse()
192                .unwrap_or_else(|_| Uri::from_static("http://localhost")),
193        )
194        .timeout(Duration::from_millis(1));
195        let _ = client.execute(spec).await;
196    }
197}