Skip to main content

cripsy_binary_api/transport/
http.rs

1//! Cliente HTTP asíncrono (`reqwest`).
2//!
3//! Reglas de la capa: toda petición lleva tiempo límite, la URL
4//! completa se loggea sin cuerpos (los cuerpos pueden traer credenciales), y
5//! los errores HTTP se convierten en [`TransportError`] antes de subir.
6
7use 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
16/// Cliente HTTP con base URL, timeouts y reintentos.
17pub struct HttpClient {
18    inner: reqwest::Client,
19    base_url: String,
20    cfg: TransportConfig,
21}
22
23impl HttpClient {
24    /// Crea el cliente. `base_url` sin barra final, p. ej. `https://iqoption.com/api`.
25    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            // Solo para pruebas documentadas: nunca en producción.
34            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    /// Acceso al cliente `reqwest` subyacente (para cookies y headers).
49    pub fn raw(&self) -> &reqwest::Client {
50        &self.inner
51    }
52
53    /// URL completa de un path relativo.
54    pub fn url(&self, path: &str) -> String {
55        format!("{}/{}", self.base_url, path.trim_start_matches('/'))
56    }
57
58    /// POST JSON con reintentos. El cuerpo viaja como `serde_json::Value`.
59    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    /// POST JSON devolviendo también las cabeceras de respuesta
65    /// (necesario para leer `Set-Cookie: ssid=…` del login).
66    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    /// POST de formulario URL-encoded con reintentos.
86    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    /// GET con reintentos.
108    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    /// Un solo envío (sin reintentos) de POST JSON.
124    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
138/// Convierte la respuesta en JSON o en error HTTP tipado.
139async 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        // El cuerpo de error puede tener detalles: se trunca para no llenar logs.
144        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        // Servidor efímero: 404 tipado sin entrar a la red real.
178        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}