use crate::error::BaseError;
use crate::http::request::RequestBuilder;
use reqwest::{Client, Method};
use std::sync::{Arc, OnceLock, RwLock};
use std::time::Duration;
static GLOBAL_HTTP_CLIENT: OnceLock<HttpClient> = OnceLock::new();
#[derive(Debug, Clone)]
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>,
}
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,
}
}
}
#[derive(Clone, Debug)]
pub struct HttpClient {
client: Client,
default_timeout: Duration,
default_token: Arc<RwLock<Option<String>>>,
}
impl HttpClient {
pub fn with_config(cfg: HttpClientConfig) -> Result<Self, BaseError> {
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);
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)?;
Ok(Self {
client,
default_timeout: Duration::from_secs(cfg.timeout_secs),
default_token: Arc::new(RwLock::new(None)),
})
}
pub fn new(timeout_secs: u64) -> Result<Self, BaseError> {
Self::with_config(HttpClientConfig {
timeout_secs,
..Default::default()
})
}
pub fn init_global(timeout_secs: u64) -> Result<(), BaseError> {
let client = Self::new(timeout_secs)?;
GLOBAL_HTTP_CLIENT
.set(client)
.map_err(|_| BaseError::HttpClientAlreadyInitialized)?;
log::info!("全局 HTTP 客户端已初始化,超时时间: {} 秒", timeout_secs);
Ok(())
}
pub fn global() -> Result<&'static HttpClient, BaseError> {
GLOBAL_HTTP_CLIENT
.get()
.ok_or(BaseError::HttpClientNotInitialized)
}
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.get_default_token(),
)
}
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)
}
}