yaiko_core/
http_client.rs1use 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}