use crate::error::BaseError;
use crate::http::request::RequestBuilder;
use reqwest::{Client, Method};
use std::sync::{Arc, RwLock};
use std::time::Duration;
const DEFAULT_MAX_RESPONSE_BYTES: usize = 10 * 1024 * 1024;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum HttpRedirectPolicy {
None,
Limited(usize),
}
impl Default for HttpRedirectPolicy {
fn default() -> Self {
Self::Limited(10)
}
}
impl HttpRedirectPolicy {
fn to_reqwest(self) -> reqwest::redirect::Policy {
match self {
Self::None => reqwest::redirect::Policy::none(),
Self::Limited(max) => reqwest::redirect::Policy::limited(max),
}
}
}
#[derive(Debug, Clone)]
#[non_exhaustive]
pub struct HttpClientConfig {
pub timeout_secs: u64,
pub pool_max_idle_per_host: usize,
pub pool_idle_timeout_secs: u64,
pub user_agent: Option<String>,
pub accept_invalid_certs: bool,
pub proxy_url: Option<String>,
pub circuit_breaker: Option<crate::http::CircuitBreakerConfig>,
pub max_response_bytes: usize,
pub redirect: HttpRedirectPolicy,
}
impl Default for HttpClientConfig {
fn default() -> Self {
Self {
timeout_secs: 30,
pool_max_idle_per_host: 10,
pool_idle_timeout_secs: 90,
user_agent: None,
accept_invalid_certs: false,
proxy_url: None,
circuit_breaker: None,
max_response_bytes: DEFAULT_MAX_RESPONSE_BYTES,
redirect: HttpRedirectPolicy::default(),
}
}
}
impl HttpClientConfig {
pub fn validate(&self) -> Result<(), BaseError> {
if self.timeout_secs == 0 {
return Err(BaseError::ParamInvalid(
"http.timeout_secs".to_string(),
"HTTP 请求超时时间必须大于 0 秒".to_string(),
));
}
if self.pool_max_idle_per_host == 0 {
return Err(BaseError::ParamInvalid(
"http.pool_max_idle_per_host".to_string(),
"每个主机最大空闲连接数必须大于 0".to_string(),
));
}
if self.pool_idle_timeout_secs == 0 {
return Err(BaseError::ParamInvalid(
"http.pool_idle_timeout_secs".to_string(),
"连接池空闲超时时间必须大于 0 秒".to_string(),
));
}
if self.max_response_bytes == 0 {
return Err(BaseError::ParamInvalid(
"http.max_response_bytes".to_string(),
"HTTP 响应体上限必须大于 0 字节".to_string(),
));
}
if let Some(circuit_breaker) = &self.circuit_breaker {
circuit_breaker.validate()?;
}
Ok(())
}
}
#[cfg(test)]
mod config_tests {
use super::*;
#[test]
fn test_http_client_config_validate_rejects_zero_values() {
let invalid_configs = [
HttpClientConfig {
timeout_secs: 0,
..HttpClientConfig::default()
},
HttpClientConfig {
pool_max_idle_per_host: 0,
..HttpClientConfig::default()
},
HttpClientConfig {
pool_idle_timeout_secs: 0,
..HttpClientConfig::default()
},
HttpClientConfig {
max_response_bytes: 0,
..HttpClientConfig::default()
},
];
for config in invalid_configs {
let err = config.validate().expect_err("HTTP 客户端零值配置应被拒绝");
assert!(matches!(err, BaseError::ParamInvalid(_, _)));
}
}
#[test]
fn test_with_config_rejects_invalid_config_before_building_client() {
let config = HttpClientConfig {
timeout_secs: 0,
..HttpClientConfig::default()
};
let err = HttpClient::with_config(config)
.expect_err("无效 HTTP 配置应在构建 reqwest client 前被拒绝");
assert!(matches!(err, BaseError::ParamInvalid(field, _) if field == "http.timeout_secs"));
}
#[test]
fn test_http_client_config_validate_rejects_invalid_circuit_breaker_config() {
let config = HttpClientConfig {
circuit_breaker: Some(crate::http::CircuitBreakerConfig {
failure_threshold: 0,
..crate::http::CircuitBreakerConfig::default()
}),
..HttpClientConfig::default()
};
let err = config
.validate()
.expect_err("HTTP 客户端应拒绝非法熔断器配置");
assert!(matches!(
err,
BaseError::ParamInvalid(field, _) if field == "http.circuit_breaker.failure_threshold"
));
}
#[test]
fn test_default_redirect_policy_stays_backward_compatible_and_validates() {
assert_eq!(
HttpClientConfig::default().redirect,
HttpRedirectPolicy::Limited(10)
);
assert_eq!(
HttpRedirectPolicy::default(),
HttpRedirectPolicy::Limited(10)
);
assert!(HttpClientConfig::default().validate().is_ok());
assert!(HttpClientConfig {
redirect: HttpRedirectPolicy::None,
..HttpClientConfig::default()
}
.validate()
.is_ok());
assert!(HttpClientConfig {
redirect: HttpRedirectPolicy::Limited(0),
..HttpClientConfig::default()
}
.validate()
.is_ok());
}
}
#[cfg(test)]
mod redirect_policy_tests {
use super::*;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
async fn serve_once(response: Vec<u8>) -> std::net::SocketAddr {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("本地监听端口应可绑定");
let addr = listener.local_addr().expect("应能取得监听地址");
tokio::spawn(async move {
let Ok((mut stream, _)) = listener.accept().await else {
return;
};
let mut buf = [0u8; 4096];
let _ = stream.read(&mut buf).await;
let _ = stream.write_all(&response).await;
let _ = stream.shutdown().await;
});
addr
}
fn found_response(location: &str) -> Vec<u8> {
format!(
"HTTP/1.1 302 Found\r\nLocation: {location}\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"
)
.into_bytes()
}
fn ok_response(body: &str) -> Vec<u8> {
format!(
"HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
body.len()
)
.into_bytes()
}
#[tokio::test]
async fn test_default_redirect_policy_follows_302_as_before() {
let target = serve_once(ok_response("ok")).await;
let target_url = format!("http://{target}/final");
let origin = serve_once(found_response(&target_url)).await;
let client = HttpClient::new(5).expect("默认客户端应可创建");
let response = client
.get(&format!("http://{origin}/start"))
.send()
.await
.expect("默认策略下请求应成功");
assert_eq!(response.status(), 200, "默认策略应跟随 302");
assert_eq!(
response.url(),
target_url,
"Response::url() 应返回跟随重定向后的最终 URL"
);
assert_eq!(
response.text().await.expect("应读到最终响应体"),
"ok",
"默认策略应落到重定向目标"
);
}
#[tokio::test]
async fn test_redirect_policy_none_returns_3xx_without_following() {
let target = serve_once(ok_response("must-not-be-read")).await;
let target_url = format!("http://{target}/final");
let origin = serve_once(found_response(&target_url)).await;
let client = HttpClient::with_config(HttpClientConfig {
redirect: HttpRedirectPolicy::None,
..HttpClientConfig::default()
})
.expect("合法配置应创建客户端");
let response = client
.get(&format!("http://{origin}/start"))
.send()
.await
.expect("None 策略下 3xx 应作为成功响应返回");
assert_eq!(response.status(), 302, "None 应原样返回 3xx");
let location = response
.headers()
.get(reqwest::header::LOCATION)
.and_then(|value| value.to_str().ok())
.map(str::to_string);
assert_eq!(
location.as_deref(),
Some(target_url.as_str()),
"Location 必须保留给调用方做逐跳校验"
);
}
#[tokio::test]
async fn test_redirect_policy_limited_stops_after_configured_hops() {
let final_server = serve_once(ok_response("too-far")).await;
let second_url = format!("http://{final_server}/second");
let second = serve_once(found_response(&second_url)).await;
let first_url = format!("http://{second}/first");
let origin = serve_once(found_response(&first_url)).await;
let client = HttpClient::with_config(HttpClientConfig {
redirect: HttpRedirectPolicy::Limited(1),
..HttpClientConfig::default()
})
.expect("合法配置应创建客户端");
let err = match client.get(&format!("http://{origin}/start")).send().await {
Ok(_) => panic!("超过跳数上限应返回请求错误"),
Err(err) => err,
};
assert!(
matches!(&err, BaseError::HttpRequestFailed(_)),
"跳数超限应映射为 HttpRequestFailed,实际: {err:?}"
);
}
}
#[derive(Clone, Debug)]
pub struct HttpClient {
client: Client,
default_timeout: Duration,
max_response_bytes: usize,
default_token: Arc<RwLock<Option<String>>>,
circuit_breaker: Option<crate::http::CircuitBreaker>,
}
impl HttpClient {
pub fn with_config(cfg: HttpClientConfig) -> Result<Self, BaseError> {
cfg.validate()?;
let _ = rustls::crypto::ring::default_provider().install_default();
let mut builder = Client::builder()
.timeout(Duration::from_secs(cfg.timeout_secs))
.pool_max_idle_per_host(cfg.pool_max_idle_per_host)
.pool_idle_timeout(Duration::from_secs(cfg.pool_idle_timeout_secs))
.danger_accept_invalid_certs(cfg.accept_invalid_certs);
builder = builder.redirect(cfg.redirect.to_reqwest());
if let Some(ua) = cfg.user_agent {
builder = builder.user_agent(ua);
}
if let Some(proxy_url) = cfg.proxy_url {
let proxy =
reqwest::Proxy::all(&proxy_url).map_err(BaseError::HttpClientCreateFailed)?;
builder = builder.proxy(proxy);
}
let client = builder.build().map_err(BaseError::HttpClientCreateFailed)?;
let circuit_breaker = cfg
.circuit_breaker
.map(crate::http::CircuitBreaker::new)
.transpose()?;
Ok(Self {
client,
default_timeout: Duration::from_secs(cfg.timeout_secs),
max_response_bytes: cfg.max_response_bytes,
default_token: Arc::new(RwLock::new(None)),
circuit_breaker,
})
}
pub fn new(timeout_secs: u64) -> Result<Self, BaseError> {
Self::with_config(HttpClientConfig {
timeout_secs,
..Default::default()
})
}
pub fn set_default_token(&self, token: String) {
let mut default_token = self
.default_token
.write()
.unwrap_or_else(|p| p.into_inner());
*default_token = Some(token);
log::debug!("已设置默认 Token");
}
fn get_default_token(&self) -> Option<String> {
let default_token = self.default_token.read().unwrap_or_else(|p| p.into_inner());
default_token.clone()
}
pub fn request(&self, method: Method, url: &str) -> RequestBuilder {
RequestBuilder::new(
self.client.clone(),
method,
url.to_string(),
self.default_timeout,
self.max_response_bytes,
self.get_default_token(),
self.circuit_breaker.clone(),
)
}
pub fn get(&self, url: &str) -> RequestBuilder {
self.request(Method::GET, url)
}
pub fn post(&self, url: &str) -> RequestBuilder {
self.request(Method::POST, url)
}
pub fn put(&self, url: &str) -> RequestBuilder {
self.request(Method::PUT, url)
}
pub fn delete(&self, url: &str) -> RequestBuilder {
self.request(Method::DELETE, url)
}
pub fn patch(&self, url: &str) -> RequestBuilder {
self.request(Method::PATCH, url)
}
}