cripsy_binary_api/transport/
http.rs1use std::time::Duration;
8
9use serde_json::Value;
10
11use crate::broker::config::TransportConfig;
12
13use super::error::TransportError;
14use super::retry::with_retry;
15
16pub struct HttpClient {
18 inner: reqwest::Client,
19 base_url: String,
20 cfg: TransportConfig,
21}
22
23impl HttpClient {
24 pub fn new(base_url: &str, cfg: TransportConfig) -> Result<Self, TransportError> {
26 let mut builder = reqwest::Client::builder()
27 .timeout(Duration::from_secs(cfg.request_timeout_secs))
28 .connect_timeout(Duration::from_secs(cfg.connect_timeout_secs));
29 if let Some(ua) = &cfg.user_agent {
30 builder = builder.user_agent(ua.clone());
31 }
32 if !cfg.verify_tls {
33 builder = builder.danger_accept_invalid_certs(true);
35 }
36 if let Some(proxy) = &cfg.proxy {
37 builder = builder
38 .proxy(reqwest::Proxy::all(proxy).map_err(|e| TransportError::Url(e.to_string()))?);
39 }
40 let inner = builder.build().map_err(TransportError::from)?;
41 Ok(Self {
42 inner,
43 base_url: base_url.trim_end_matches('/').to_string(),
44 cfg,
45 })
46 }
47
48 pub fn raw(&self) -> &reqwest::Client {
50 &self.inner
51 }
52
53 pub fn url(&self, path: &str) -> String {
55 format!("{}/{}", self.base_url, path.trim_start_matches('/'))
56 }
57
58 pub async fn post_json(&self, path: &str, cuerpo: &Value) -> Result<Value, TransportError> {
60 let cfg = self.cfg.clone();
61 with_retry(&cfg, path, || self.enviar(path, cuerpo)).await
62 }
63
64 pub async fn post_json_completo(
67 &self,
68 path: &str,
69 cuerpo: &Value,
70 ) -> Result<(Value, reqwest::header::HeaderMap), TransportError> {
71 let url = self.url(path);
72 tracing::debug!(url = %url, "POST http (con cabeceras)");
73 let resp = self
74 .inner
75 .post(&url)
76 .json(cuerpo)
77 .send()
78 .await
79 .map_err(TransportError::from)?;
80 let headers = resp.headers().clone();
81 let cuerpo_resp = decodificar(resp).await?;
82 Ok((cuerpo_resp, headers))
83 }
84
85 pub async fn post_form(
87 &self,
88 path: &str,
89 campos: &[(String, String)],
90 ) -> Result<Value, TransportError> {
91 let url = self.url(path);
92 let cfg = self.cfg.clone();
93 let campos = campos.to_vec();
94 with_retry(&cfg, path, || async {
95 let resp = self
96 .inner
97 .post(&url)
98 .form(&campos)
99 .send()
100 .await
101 .map_err(TransportError::from)?;
102 decodificar(resp).await
103 })
104 .await
105 }
106
107 pub async fn get_json(&self, path: &str) -> Result<Value, TransportError> {
109 let url = self.url(path);
110 let cfg = self.cfg.clone();
111 with_retry(&cfg, path, || async {
112 let resp = self
113 .inner
114 .get(&url)
115 .send()
116 .await
117 .map_err(TransportError::from)?;
118 decodificar(resp).await
119 })
120 .await
121 }
122
123 async fn enviar(&self, path: &str, cuerpo: &Value) -> Result<Value, TransportError> {
125 let url = self.url(path);
126 tracing::debug!(url = %url, "POST http");
127 let resp = self
128 .inner
129 .post(&url)
130 .json(cuerpo)
131 .send()
132 .await
133 .map_err(TransportError::from)?;
134 decodificar(resp).await
135 }
136}
137
138async fn decodificar(resp: reqwest::Response) -> Result<Value, TransportError> {
140 let status = resp.status();
141 if !status.is_success() {
142 let body = resp.text().await.unwrap_or_default();
143 let body: String = body.chars().take(500).collect();
145 return Err(TransportError::Http {
146 status: status.as_u16(),
147 body,
148 });
149 }
150 resp.json::<Value>()
151 .await
152 .map_err(|e| TransportError::Codec(e.to_string()))
153}
154
155#[cfg(test)]
156mod tests {
157 use super::*;
158
159 #[test]
160 fn url_une_base_y_path() {
161 let http = HttpClient::new("https://ejemplo.com/api", TransportConfig::default()).unwrap();
162 assert_eq!(http.url("/v2/login"), "https://ejemplo.com/api/v2/login");
163 assert_eq!(http.url("v2/login"), "https://ejemplo.com/api/v2/login");
164 let http2 =
165 HttpClient::new("https://ejemplo.com/api/", TransportConfig::default()).unwrap();
166 assert_eq!(http2.url("x"), "https://ejemplo.com/api/x");
167 }
168
169 #[test]
170 fn cliente_valido_se_construye() {
171 let http = HttpClient::new("https://ejemplo.com", TransportConfig::default()).unwrap();
172 assert_eq!(http.url("/x"), "https://ejemplo.com/x");
173 }
174
175 #[tokio::test]
176 async fn http_status_se_convierte_en_error_tipado() {
177 use std::net::SocketAddr;
179 let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
180 let addr: SocketAddr = listener.local_addr().unwrap();
181 tokio::spawn(async move {
182 use tokio::io::{AsyncReadExt, AsyncWriteExt};
183 loop {
184 let (mut sock, _) = listener.accept().await.unwrap();
185 tokio::spawn(async move {
186 let mut buf = [0u8; 1024];
187 let _ = sock.read(&mut buf).await;
188 let _ = sock
189 .write_all(b"HTTP/1.1 404 Not Found\r\ncontent-length: 0\r\n\r\n")
190 .await;
191 });
192 }
193 });
194 let cfg = TransportConfig {
195 max_retries: 0,
196 ..TransportConfig::default()
197 };
198 let http = HttpClient::new(&format!("http://{addr}"), cfg).unwrap();
199 let err = http.get_json("/x").await.expect_err("debe fallar con 404");
200 match err {
201 TransportError::Http { status, body } => {
202 assert_eq!(status, 404);
203 assert!(body.is_empty());
204 }
205 otra => panic!("error inesperado: {otra:?}"),
206 }
207 }
208}