use std::collections::HashMap;
use std::sync::Arc;
use std::time::Duration;
use http::Method;
#[cfg(any(feature = "http1", feature = "http2"))]
use hyper_util::rt::TokioExecutor;
#[cfg(any(feature = "http1", feature = "http2"))]
use tokio::sync::Mutex;
use crate::error::{Error, Result};
use crate::headers::Headers;
use crate::http_version::HttpVersionPolicy;
use crate::limits::Limits;
use crate::pool::{Pool, PoolConfig, PoolMetrics};
#[cfg(feature = "proxy")]
use crate::proxy::Proxy;
use crate::redirect::RedirectPolicy;
use crate::request::{Request, RequestBuilder};
use crate::response::Response;
use crate::retry::RetryPolicy;
use crate::timeout::Timeout;
use crate::transport::Connector;
#[cfg(feature = "cookies")]
use crate::cookie::CookieJar;
#[derive(Clone)]
pub(crate) struct ClientConfig {
pub(crate) default_headers: Headers,
pub(crate) user_agent: Option<String>,
pub(crate) timeout: Option<Timeout>,
pub(crate) redirect: RedirectPolicy,
pub(crate) auth: Option<crate::auth::AuthScheme>,
#[cfg(feature = "cookies")]
pub(crate) cookie_jar: CookieJar,
pub(crate) automatic_decompression: bool,
pub(crate) max_decoded_body_size: Option<usize>,
pub(crate) max_decompression_ratio: Option<f64>,
#[cfg(feature = "proxy")]
pub(crate) proxy: Option<Proxy>,
#[cfg(feature = "proxy")]
pub(crate) environment_proxies: Vec<Proxy>,
#[cfg(feature = "tls-rustls")]
pub(crate) tls_config: Option<crate::tls::TlsConfig>,
pub(crate) retry: Option<RetryPolicy>,
#[allow(
dead_code,
reason = "stored for inspection and future request-level use"
)]
pub(crate) http_version_policy: HttpVersionPolicy,
}
impl std::fmt::Debug for ClientConfig {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut debug = f.debug_struct("ClientConfig");
debug
.field("default_headers", &self.default_headers)
.field("user_agent", &self.user_agent)
.field("timeout", &self.timeout)
.field("redirect", &self.redirect)
.field("auth", &self.auth);
#[cfg(feature = "cookies")]
debug.field("cookie_jar", &self.cookie_jar);
debug
.field("automatic_decompression", &self.automatic_decompression)
.field("max_decoded_body_size", &self.max_decoded_body_size)
.field("max_decompression_ratio", &self.max_decompression_ratio);
#[cfg(feature = "proxy")]
debug
.field("proxy", &self.proxy)
.field("environment_proxies", &self.environment_proxies);
#[cfg(feature = "tls-rustls")]
debug.field("tls_config", &self.tls_config);
debug
.field("retry", &self.retry)
.field("http_version_policy", &self.http_version_policy)
.finish_non_exhaustive()
}
}
impl Default for ClientConfig {
fn default() -> Self {
Self {
default_headers: Headers::new(),
user_agent: None,
timeout: None,
redirect: RedirectPolicy::default(),
auth: None,
#[cfg(feature = "cookies")]
cookie_jar: CookieJar::new(),
automatic_decompression: true,
max_decoded_body_size: None,
max_decompression_ratio: None,
#[cfg(feature = "proxy")]
proxy: None,
#[cfg(feature = "proxy")]
environment_proxies: Vec::new(),
#[cfg(feature = "tls-rustls")]
tls_config: None,
retry: None,
http_version_policy: HttpVersionPolicy::default(),
}
}
}
#[derive(Clone)]
pub struct Client {
inner: Arc<ClientInner>,
}
impl std::fmt::Debug for Client {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Client").finish_non_exhaustive()
}
}
pub(crate) struct ClientInner {
#[cfg(any(feature = "http1", feature = "http2"))]
pub(crate) hyper_client: Option<crate::transport::TimeoutHyperClient>,
#[cfg(feature = "tls-rustls")]
pub(crate) tls_config_error: Option<String>,
#[cfg(any(feature = "http1", feature = "http2"))]
pub(crate) direct_client: Option<crate::transport::TimeoutDirectClient>,
#[cfg(any(feature = "http1", feature = "http2"))]
pub(crate) direct_connector_config:
Option<crate::transport::direct_connector::DirectConnectorConfig>,
#[cfg(any(feature = "http1", feature = "http2"))]
pub(crate) sni_clients: Mutex<HashMap<String, crate::transport::TimeoutDirectClient>>,
#[cfg(unix)]
#[cfg(any(feature = "http1", feature = "http2"))]
pub(crate) uds_client: Option<crate::transport::TimeoutUdsClient>,
#[cfg(feature = "proxy")]
pub(crate) socks_clients: Mutex<
HashMap<crate::transport::socks::SocksRouteKey, crate::transport::TimeoutSocksClient>,
>,
pub(crate) config: ClientConfig,
pub(crate) pool: Pool,
pub(crate) transport_metrics: Arc<crate::transport::metrics::TransportMetrics>,
#[cfg(feature = "http3")]
pub(crate) h3_connector: Option<crate::transport::http3::H3Connector>,
#[cfg(feature = "http3")]
pub(crate) alt_svc_state: Arc<crate::transport::alt_svc::AltSvcState>,
}
const SNI_CLIENT_CACHE_MAX_ENTRIES: usize = 256;
#[cfg(feature = "proxy")]
const SOCKS_CLIENT_CACHE_MAX_ENTRIES: usize = 64;
fn evict_one<K: std::clone::Clone + Eq + std::hash::Hash, V>(map: &mut HashMap<K, V>) {
if let Some(key) = map.keys().next().cloned() {
map.remove(&key);
}
}
#[cfg(feature = "tls-rustls")]
pub(crate) fn configure_tls_alpn(
mut config: rustls::ClientConfig,
policy: crate::http_version::HttpVersionPolicyEnabler,
) -> rustls::ClientConfig {
config.alpn_protocols.clear();
if policy.enable_http2() {
config.alpn_protocols.push(b"h2".to_vec());
}
if policy.enable_http1() {
config.alpn_protocols.push(b"http/1.1".to_vec());
}
config
}
impl ClientInner {
#[cfg(any(feature = "http1", feature = "http2"))]
pub(crate) fn resolved_client(
&self,
target: &crate::request::ResolvedTarget,
sni_hostname: Option<&str>,
) -> Result<crate::transport::TimeoutDirectClient> {
let connect_timeout = self.config.timeout.as_ref().and_then(|t| t.connect);
#[cfg(feature = "tls-rustls")]
let tls_connector = {
let tls_config = self.config.tls_config.clone().unwrap_or_default();
let rustls_config = tls_config
.build_rustls_config()
.map_err(|e| Error::Tls(format!("failed to build TLS config: {e}")))?;
let rustls_config = configure_tls_alpn(
rustls_config,
crate::http_version::HttpVersionPolicyEnabler::from_policy(
self.config.http_version_policy,
),
);
Some(tokio_rustls::TlsConnector::from(Arc::new(rustls_config)))
};
#[cfg(not(feature = "tls-rustls"))]
let tls_connector = None;
let base_config = self.direct_connector_config.clone().unwrap_or(
crate::transport::direct_connector::DirectConnectorConfig {
local_address: None,
socket_options: Vec::new(),
},
);
let mut connector = crate::transport::direct_connector::DirectConnector::with_metrics(
base_config,
tls_connector,
self.transport_metrics.clone(),
)
.with_resolved_target(target);
if let Some(sni_hostname) = sni_hostname {
connector = connector.with_sni(sni_hostname.to_owned());
}
let connector =
crate::transport::connect_timeout::ConnectTimeout::new(connector, connect_timeout);
let mut builder = hyper_util::client::legacy::Client::builder(TokioExecutor::new());
#[cfg(feature = "http2")]
if !crate::http_version::HttpVersionPolicyEnabler::from_policy(
self.config.http_version_policy,
)
.enable_http1()
&& crate::http_version::HttpVersionPolicyEnabler::from_policy(
self.config.http_version_policy,
)
.enable_http2()
{
builder.http2_only(true);
}
if let Some(idle_timeout) = self.pool.idle_timeout() {
builder.pool_idle_timeout(idle_timeout);
}
Ok(builder.build(connector))
}
#[cfg(any(feature = "http1", feature = "http2"))]
pub(crate) async fn sni_client(
&self,
sni_hostname: &str,
) -> Result<crate::transport::TimeoutDirectClient> {
let mut clients = self.sni_clients.lock().await;
if let Some(client) = clients.get(sni_hostname) {
return Ok(client.clone());
}
let connect_timeout = self.config.timeout.as_ref().and_then(|t| t.connect);
#[cfg(any(feature = "tls-rustls", feature = "http2"))]
let policy = self.config.http_version_policy;
#[cfg(feature = "tls-rustls")]
let tls_connector = {
let tls_config = self.config.tls_config.clone().unwrap_or_default();
let rc = tls_config
.build_rustls_config()
.map_err(|e| Error::Tls(format!("failed to build TLS config: {e}")))?;
let rc = configure_tls_alpn(
rc,
crate::http_version::HttpVersionPolicyEnabler::from_policy(policy),
);
Some(tokio_rustls::TlsConnector::from(Arc::new(rc)))
};
#[cfg(not(feature = "tls-rustls"))]
let tls_connector = None;
let base_config = self.direct_connector_config.clone().unwrap_or(
crate::transport::direct_connector::DirectConnectorConfig {
local_address: None,
socket_options: Vec::new(),
},
);
let base_connector = crate::transport::direct_connector::DirectConnector::with_metrics(
base_config,
tls_connector,
self.transport_metrics.clone(),
);
let sni_connector = base_connector.with_sni(sni_hostname.to_owned());
let connector =
crate::transport::connect_timeout::ConnectTimeout::new(sni_connector, connect_timeout);
let mut builder =
hyper_util::client::legacy::Client::builder(hyper_util::rt::TokioExecutor::new());
#[cfg(feature = "http2")]
if matches!(policy, crate::HttpVersionPolicy::Http2Only) {
builder.http2_only(true);
}
if let Some(idle_timeout) = self.pool.idle_timeout() {
builder.pool_idle_timeout(idle_timeout);
}
let client = builder.build(connector);
if clients.len() >= SNI_CLIENT_CACHE_MAX_ENTRIES {
evict_one(&mut clients);
}
clients.insert(sni_hostname.to_owned(), client.clone());
Ok(client)
}
}
#[cfg(feature = "proxy")]
impl ClientInner {
pub(crate) async fn socks_client(
&self,
proxy: &crate::proxy::ProxyConfig,
) -> Result<crate::transport::TimeoutSocksClient> {
let key = crate::transport::socks::SocksRouteKey::from_proxy(proxy)?;
let mut clients = self.socks_clients.lock().await;
if let Some(client) = clients.get(&key) {
return Ok(client.clone());
}
let policy = self.config.http_version_policy;
let tls_config = if let Some(config) = self.config.tls_config.as_ref() {
config
.build_rustls_config()
.map_err(|e| Error::Tls(format!("failed to build SOCKS TLS config: {e}")))?
} else {
crate::tls::TlsConfig::default()
.build_rustls_config()
.map_err(|e| Error::Tls(format!("failed to build default SOCKS TLS config: {e}")))?
};
let tls_config = configure_tls_alpn(
tls_config,
crate::http_version::HttpVersionPolicyEnabler::from_policy(policy),
);
let connector = crate::transport::socks::SocksConnector::new(
proxy.clone(),
Some(tokio_rustls::TlsConnector::from(Arc::new(tls_config))),
None,
);
let connector = crate::transport::connect_timeout::ConnectTimeout::new(
connector,
self.config
.timeout
.as_ref()
.and_then(|timeout| timeout.connect),
);
let mut builder =
hyper_util::client::legacy::Client::builder(hyper_util::rt::TokioExecutor::new());
#[cfg(feature = "http2")]
if matches!(policy, crate::HttpVersionPolicy::Http2Only) {
builder.http2_only(true);
}
let client = builder.build(connector);
if clients.len() >= SOCKS_CLIENT_CACHE_MAX_ENTRIES {
evict_one(&mut clients);
}
clients.insert(key, client.clone());
Ok(client)
}
}
impl Client {
#[must_use]
pub fn new() -> Self {
Self::builder().build()
}
#[must_use]
pub fn builder() -> ClientBuilder {
ClientBuilder::new()
}
pub fn get(&self, url: &str) -> Result<RequestBuilder> {
self.request(Method::GET, url)
}
pub fn post(&self, url: &str) -> Result<RequestBuilder> {
self.request(Method::POST, url)
}
pub fn put(&self, url: &str) -> Result<RequestBuilder> {
self.request(Method::PUT, url)
}
pub fn patch(&self, url: &str) -> Result<RequestBuilder> {
self.request(Method::PATCH, url)
}
pub fn delete(&self, url: &str) -> Result<RequestBuilder> {
self.request(Method::DELETE, url)
}
pub fn head(&self, url: &str) -> Result<RequestBuilder> {
self.request(Method::HEAD, url)
}
pub fn options(&self, url: &str) -> Result<RequestBuilder> {
self.request(Method::OPTIONS, url)
}
pub fn request(&self, method: Method, url: &str) -> Result<RequestBuilder> {
let parsed = parse_url(url)?;
Ok(RequestBuilder::new(self.clone(), method, parsed))
}
#[must_use]
pub fn pool_metrics(&self) -> &PoolMetrics {
self.inner.pool.metrics()
}
#[must_use]
pub fn transport_metrics(&self) -> &crate::transport::metrics::TransportMetrics {
&self.inner.transport_metrics
}
#[cfg(feature = "cookies")]
#[must_use]
pub fn cookies(&self) -> &CookieJar {
&self.inner.config.cookie_jar
}
#[must_use]
pub(crate) fn config(&self) -> &ClientConfig {
&self.inner.config
}
pub(crate) async fn send(&self, request: Request) -> Result<Response> {
Box::pin(crate::pipeline::send_with_retry(self, request)).await
}
pub(crate) async fn send_single_request(
&self,
request: Request,
timeout: &Timeout,
) -> Result<Response> {
crate::pipeline::send_single_request(&self.inner, request, timeout).await
}
}
impl Default for Client {
fn default() -> Self {
Self::new()
}
}
pub struct ClientBuilder {
default_headers: Headers,
user_agent: Option<String>,
pool_config: PoolConfig,
timeout: Option<Timeout>,
limits: Option<Limits>,
redirect: RedirectPolicy,
auth: Option<crate::auth::AuthScheme>,
#[cfg(feature = "cookies")]
cookie_jar: Option<CookieJar>,
automatic_decompression: Option<bool>,
max_decoded_body_size: Option<usize>,
max_decompression_ratio: Option<f64>,
#[cfg(feature = "proxy")]
proxy: Option<Proxy>,
#[cfg(feature = "proxy")]
environment_proxies: Vec<Proxy>,
#[cfg(feature = "tls-rustls")]
tls_config: Option<crate::tls::TlsConfig>,
retry: Option<RetryPolicy>,
http_version_policy: HttpVersionPolicy,
direct_connector_config: Option<crate::transport::direct_connector::DirectConnectorConfig>,
uds_path: Option<String>,
}
impl ClientBuilder {
#[must_use]
pub fn new() -> Self {
Self {
default_headers: Headers::new(),
user_agent: None,
pool_config: PoolConfig::default(),
timeout: None,
limits: None,
redirect: RedirectPolicy::default(),
auth: None,
#[cfg(feature = "cookies")]
cookie_jar: None,
automatic_decompression: None,
max_decoded_body_size: None,
max_decompression_ratio: None,
#[cfg(feature = "proxy")]
proxy: None,
#[cfg(feature = "proxy")]
environment_proxies: Vec::new(),
#[cfg(feature = "tls-rustls")]
tls_config: None,
retry: None,
http_version_policy: HttpVersionPolicy::default(),
direct_connector_config: None,
uds_path: None,
}
}
pub fn default_header(mut self, name: &str, value: &str) -> Result<Self> {
self.default_headers.insert(name, value)?;
Ok(self)
}
#[must_use]
pub fn default_headers(mut self, headers: Headers) -> Self {
self.default_headers = headers;
self
}
#[must_use]
pub fn user_agent(mut self, agent: &str) -> Self {
self.user_agent = Some(agent.to_owned());
self
}
#[must_use]
pub fn max_idle_connections(mut self, max: usize) -> Self {
self.pool_config.max_idle_connections = Some(max);
self
}
#[must_use]
pub fn max_idle_connections_per_host(mut self, max: usize) -> Self {
self.pool_config.max_idle_connections_per_host = Some(max);
self
}
#[must_use]
pub fn max_connections(mut self, max: usize) -> Self {
self.pool_config.max_connections = Some(max);
self
}
#[must_use]
pub fn max_connections_per_host(mut self, max: usize) -> Self {
self.pool_config.max_connections_per_host = Some(max);
self
}
#[must_use]
pub fn max_in_flight_requests(mut self, max: usize) -> Self {
self.pool_config.max_in_flight_requests = Some(max);
self
}
#[must_use]
pub fn max_in_flight_requests_per_origin(mut self, max: usize) -> Self {
self.pool_config.max_in_flight_requests_per_origin = Some(max);
self
}
#[must_use]
pub fn idle_timeout(mut self, timeout: Duration) -> Self {
self.pool_config.idle_timeout = Some(timeout);
self
}
#[must_use]
pub fn timeout(mut self, timeout: Timeout) -> Self {
self.timeout = Some(timeout);
self
}
#[must_use]
pub fn merge_timeout(mut self, timeout: Timeout) -> Self {
let merged = match self.timeout {
Some(existing) => existing.merge(Some(timeout)),
None => timeout,
};
self.timeout = Some(merged);
self
}
#[must_use]
pub fn limits(mut self, limits: Limits) -> Self {
self.limits = Some(limits);
self
}
#[must_use]
pub fn follow_redirects(mut self, follow: bool) -> Self {
self.redirect.follow = follow;
self
}
#[must_use]
pub fn max_redirects(mut self, max: usize) -> Self {
self.redirect.max_redirects = max;
self
}
#[must_use]
pub fn redirect_policy(mut self, policy: RedirectPolicy) -> Self {
self.redirect = policy;
self
}
#[cfg(feature = "cookies")]
#[must_use]
pub fn cookie_jar(mut self, jar: CookieJar) -> Self {
self.cookie_jar = Some(jar);
self
}
#[must_use]
pub fn auth(mut self, auth: impl Into<crate::auth::AuthScheme>) -> Self {
self.auth = Some(auth.into());
self
}
#[cfg(feature = "proxy")]
#[must_use]
pub fn proxy(mut self, proxy: Proxy) -> Self {
self.proxy = Some(proxy);
self
}
#[cfg(feature = "proxy")]
#[must_use]
pub fn environment_proxy(mut self, proxy: Proxy) -> Self {
self.environment_proxies.push(proxy);
self
}
#[cfg(feature = "proxy")]
#[must_use]
pub fn no_proxy(mut self, no_proxy: crate::proxy::NoProxy) -> Self {
if let Some(proxy) = self.proxy.take() {
self.proxy = Some(proxy.no_proxy(no_proxy));
}
self
}
#[cfg(feature = "tls-rustls")]
#[must_use]
pub fn tls_config(mut self, config: crate::tls::TlsConfig) -> Self {
self.tls_config = Some(config);
self
}
#[cfg(feature = "tls-rustls")]
#[must_use]
pub fn danger_accept_invalid_certs(mut self, accept: bool) -> Self {
let config = self.tls_config.take().unwrap_or_default();
self.tls_config = Some(config.danger_accept_invalid_certs(accept));
self
}
#[must_use]
pub fn automatic_decompression(mut self, enabled: bool) -> Self {
self.automatic_decompression = Some(enabled);
self
}
#[must_use]
pub fn max_decoded_body_size(mut self, max: usize) -> Self {
self.max_decoded_body_size = Some(max);
self
}
#[must_use]
pub fn max_decompression_ratio(mut self, ratio: f64) -> Self {
assert!(
ratio.is_finite() && ratio > 0.0,
"max_decompression_ratio must be finite and positive, got {ratio}"
);
self.max_decompression_ratio = Some(ratio);
self
}
#[must_use]
pub fn retry(mut self, policy: RetryPolicy) -> Self {
self.retry = Some(policy);
self
}
#[must_use]
pub fn http_version_policy(mut self, policy: HttpVersionPolicy) -> Self {
self.http_version_policy = policy;
self
}
#[must_use]
pub fn local_address(mut self, addr: std::net::SocketAddr) -> Self {
let config = self.direct_connector_config.get_or_insert_with(|| {
crate::transport::direct_connector::DirectConnectorConfig {
local_address: None,
socket_options: Vec::new(),
}
});
config.local_address = Some(addr);
self
}
#[must_use]
pub fn socket_options(
mut self,
options: Vec<crate::transport::direct_connector::SocketOption>,
) -> Self {
let config = self.direct_connector_config.get_or_insert_with(|| {
crate::transport::direct_connector::DirectConnectorConfig {
local_address: None,
socket_options: Vec::new(),
}
});
config.socket_options = options;
self
}
#[must_use]
pub fn uds_path(mut self, path: String) -> Self {
self.uds_path = Some(path);
self
}
#[must_use]
#[allow(clippy::too_many_lines)]
pub fn build(self) -> Client {
#[cfg(any(feature = "http1", feature = "http2"))]
use crate::http_version::HttpVersionPolicyEnabler;
#[cfg(any(feature = "http1", feature = "http2"))]
let enabler = HttpVersionPolicyEnabler::from_policy(self.http_version_policy);
let transport_metrics = Arc::new(crate::transport::metrics::TransportMetrics::new());
let mut pool_config = self.pool_config;
if let Some(limits) = self.limits {
let limits_config: PoolConfig = limits.into();
if limits_config.max_connections.is_some() {
pool_config.max_connections = limits_config.max_connections;
}
if limits_config.max_connections_per_host.is_some() {
pool_config.max_connections_per_host = limits_config.max_connections_per_host;
}
if limits_config.max_in_flight_requests.is_some() {
pool_config.max_in_flight_requests = limits_config.max_in_flight_requests;
}
if limits_config.max_in_flight_requests_per_origin.is_some() {
pool_config.max_in_flight_requests_per_origin =
limits_config.max_in_flight_requests_per_origin;
}
if limits_config.max_idle_connections.is_some() {
pool_config.max_idle_connections = limits_config.max_idle_connections;
}
if limits_config.max_idle_connections_per_host.is_some() {
pool_config.max_idle_connections_per_host =
limits_config.max_idle_connections_per_host;
}
if limits_config.idle_timeout.is_some() {
pool_config.idle_timeout = limits_config.idle_timeout;
}
}
#[cfg(feature = "cookies")]
let cookie_jar = self.cookie_jar.unwrap_or_default();
let automatic_decompression = self.automatic_decompression.unwrap_or(true);
#[cfg(feature = "tls-rustls")]
let tls_config_result = self
.tls_config
.clone()
.unwrap_or_default()
.build_rustls_config();
#[cfg(feature = "tls-rustls")]
let tls_config_error = tls_config_result
.as_ref()
.err()
.map(|error| format!("failed to build TLS config: {error}"));
#[cfg(feature = "tls-rustls")]
let hyper_client = if matches!(
self.http_version_policy,
crate::HttpVersionPolicy::Http3Only
) || tls_config_error.is_some()
{
None
} else if let Ok(rc) = tls_config_result {
let https = build_standard_connector(rc, enabler);
let connect_timeout = self.timeout.as_ref().and_then(|t| t.connect);
let https =
crate::transport::connect_timeout::ConnectTimeout::new(https, connect_timeout);
let mut builder = hyper_util::client::legacy::Client::builder(TokioExecutor::new());
#[cfg(feature = "http2")]
if !enabler.enable_http1() && enabler.enable_http2() {
builder.http2_only(true);
}
if let Some(timeout) = pool_config.idle_timeout {
builder.pool_idle_timeout(timeout);
}
if let Some(max_idle) = pool_config
.max_idle_connections_per_host
.or(pool_config.max_idle_connections)
{
builder.pool_max_idle_per_host(max_idle);
}
Some(builder.build(https))
} else {
None
};
#[cfg(all(not(feature = "tls-rustls"), any(feature = "http1", feature = "http2")))]
let hyper_client = if matches!(
self.http_version_policy,
crate::HttpVersionPolicy::Http3Only
) {
None
} else {
let connector = build_standard_connector(enabler);
let connector = crate::transport::connect_timeout::ConnectTimeout::new(
connector,
self.timeout.as_ref().and_then(|t| t.connect),
);
let mut builder = hyper_util::client::legacy::Client::builder(TokioExecutor::new());
if let Some(timeout) = pool_config.idle_timeout {
builder.pool_idle_timeout(timeout);
}
if let Some(max_idle) = pool_config
.max_idle_connections_per_host
.or(pool_config.max_idle_connections)
{
builder.pool_max_idle_per_host(max_idle);
}
Some(builder.build(connector))
};
#[cfg(feature = "http3")]
let h3_connector = if enabler.use_http3() {
crate::transport::http3::H3Connector::with_metrics(
self.tls_config.clone(),
&pool_config,
Some(transport_metrics.clone()),
)
.ok()
} else {
None
};
#[cfg(any(feature = "http1", feature = "http2"))]
let stored_direct_config = self.direct_connector_config.clone();
#[cfg(any(feature = "http1", feature = "http2"))]
let direct_client = if let Some(dc_config) = self.direct_connector_config {
let connect_timeout = self.timeout.as_ref().and_then(|t| t.connect);
#[cfg(feature = "tls-rustls")]
let tls_connector = match self
.tls_config
.clone()
.unwrap_or_default()
.build_rustls_config()
{
Ok(rc) => Some(tokio_rustls::TlsConnector::from(Arc::new(
configure_tls_alpn(
rc,
crate::http_version::HttpVersionPolicyEnabler::from_policy(
self.http_version_policy,
),
),
))),
Err(_) => None,
};
#[cfg(not(feature = "tls-rustls"))]
let tls_connector = None;
let direct_connector =
crate::transport::direct_connector::DirectConnector::with_metrics(
dc_config,
tls_connector,
transport_metrics.clone(),
);
let direct_connector = crate::transport::connect_timeout::ConnectTimeout::new(
direct_connector,
connect_timeout,
);
let mut builder = hyper_util::client::legacy::Client::builder(TokioExecutor::new());
#[cfg(feature = "http2")]
if !enabler.enable_http1() && enabler.enable_http2() {
builder.http2_only(true);
}
if let Some(timeout) = pool_config.idle_timeout {
builder.pool_idle_timeout(timeout);
}
if let Some(max_idle) = pool_config
.max_idle_connections_per_host
.or(pool_config.max_idle_connections)
{
builder.pool_max_idle_per_host(max_idle);
}
Some(builder.build(direct_connector))
} else {
None
};
#[cfg(not(unix))]
let _ = &self.uds_path;
#[cfg(all(unix, any(feature = "http1", feature = "http2")))]
let uds_client = self.uds_path.map(|path| {
#[cfg(feature = "tls-rustls")]
let tls_connector = self
.tls_config
.clone()
.unwrap_or_default()
.build_rustls_config()
.ok()
.map(|rc| {
tokio_rustls::TlsConnector::from(Arc::new(configure_tls_alpn(
rc,
crate::http_version::HttpVersionPolicyEnabler::from_policy(
self.http_version_policy,
),
)))
});
#[cfg(not(feature = "tls-rustls"))]
let tls_connector = None;
let connector = crate::transport::uds::UdsConnector::with_metrics(
path,
tls_connector,
transport_metrics.clone(),
);
let connector = crate::transport::connect_timeout::ConnectTimeout::new(
connector,
self.timeout.as_ref().and_then(|timeout| timeout.connect),
);
let mut builder = hyper_util::client::legacy::Client::builder(TokioExecutor::new());
#[cfg(feature = "http2")]
if !enabler.enable_http1() && enabler.enable_http2() {
builder.http2_only(true);
}
if let Some(timeout) = pool_config.idle_timeout {
builder.pool_idle_timeout(timeout);
}
if let Some(max_idle) = pool_config
.max_idle_connections_per_host
.or(pool_config.max_idle_connections)
{
builder.pool_max_idle_per_host(max_idle);
}
builder.build(connector)
});
let config = ClientConfig {
default_headers: self.default_headers,
user_agent: self.user_agent,
timeout: self.timeout,
redirect: self.redirect,
auth: self.auth,
#[cfg(feature = "cookies")]
cookie_jar,
automatic_decompression,
max_decoded_body_size: self.max_decoded_body_size,
max_decompression_ratio: self.max_decompression_ratio,
#[cfg(feature = "proxy")]
proxy: self.proxy,
#[cfg(feature = "proxy")]
environment_proxies: self.environment_proxies,
#[cfg(feature = "tls-rustls")]
tls_config: self.tls_config,
retry: self.retry,
http_version_policy: self.http_version_policy,
};
let pool = Pool::new(pool_config);
Client {
inner: Arc::new(ClientInner {
#[cfg(any(feature = "http1", feature = "http2"))]
hyper_client,
#[cfg(feature = "tls-rustls")]
tls_config_error,
#[cfg(any(feature = "http1", feature = "http2"))]
direct_client,
#[cfg(any(feature = "http1", feature = "http2"))]
direct_connector_config: stored_direct_config,
#[cfg(any(feature = "http1", feature = "http2"))]
sni_clients: Mutex::new(HashMap::new()),
#[cfg(all(unix, any(feature = "http1", feature = "http2")))]
uds_client,
#[cfg(feature = "proxy")]
socks_clients: Mutex::new(HashMap::new()),
config,
pool,
transport_metrics,
#[cfg(feature = "http3")]
h3_connector,
#[cfg(feature = "http3")]
alt_svc_state: Arc::new(crate::transport::alt_svc::AltSvcState::new()),
}),
}
}
}
#[cfg(not(feature = "tls-rustls"))]
fn build_standard_connector(enabler: crate::http_version::HttpVersionPolicyEnabler) -> Connector {
let _ = enabler;
let mut connector = hyper_util::client::legacy::connect::HttpConnector::new();
connector.enforce_http(true);
connector
}
#[cfg(feature = "tls-rustls")]
fn build_standard_connector(
mut config: rustls::ClientConfig,
enabler: crate::http_version::HttpVersionPolicyEnabler,
) -> Connector {
config.alpn_protocols.clear();
let builder = hyper_rustls::HttpsConnectorBuilder::new()
.with_tls_config(config)
.https_or_http();
#[cfg(feature = "http2")]
{
match (enabler.enable_http1(), enabler.enable_http2()) {
(true, true) => builder.enable_http1().enable_http2().build(),
(true | false, false) => builder.enable_http1().build(),
(false, true) => builder.enable_http2().build(),
}
}
#[cfg(not(feature = "http2"))]
{
let _ = enabler;
builder.enable_http1().build()
}
}
impl Default for ClientBuilder {
fn default() -> Self {
Self::new()
}
}
fn parse_url(url_str: &str) -> Result<url::Url> {
let url = url::Url::parse(url_str).map_err(|e| Error::InvalidUrl(e.to_string()))?;
if !url.username().is_empty() || url.password().is_some() {
return Err(Error::InvalidUrl(
"URL userinfo is not supported; configure authentication explicitly".into(),
));
}
match url.scheme() {
"http" | "https" => Ok(url),
other => Err(Error::Unsupported(format!(
"URL scheme '{other}' is not supported; use http or https"
))),
}
}
#[cfg(test)]
mod tests {
use super::*;
#[cfg(feature = "proxy")]
use crate::proxy::ProxyAuth;
use bytes::Bytes;
#[test]
fn client_constructs() {
let _client = Client::new();
}
#[test]
fn client_config_debug_redacts_secrets() {
let mut config = ClientConfig::default();
config
.default_headers
.insert("authorization", "Bearer header-secret-token")
.unwrap();
#[cfg(feature = "cookies")]
config
.cookie_jar
.set_default_cookie("session".to_owned(), "jar-secret-token".to_owned())
.expect("valid test cookie");
let debug = format!("{config:?}");
assert!(
!debug.contains("header-secret-token"),
"ClientConfig Debug must not leak header secrets: {debug}"
);
#[cfg(feature = "cookies")]
assert!(
!debug.contains("jar-secret-token"),
"ClientConfig Debug must not leak jar secrets: {debug}"
);
}
#[test]
fn client_default() {
let _client = Client::default();
}
#[test]
fn client_builder() {
let _client = Client::builder().user_agent("test-agent").build();
}
#[test]
fn client_builder_merge_timeout_preserves_other_phases() {
let client = Client::builder()
.timeout(Timeout::from_secs(30))
.merge_timeout(
Timeout::builder()
.connect(std::time::Duration::from_secs(5))
.build(),
)
.merge_timeout(
Timeout::builder()
.read(std::time::Duration::from_secs(10))
.build(),
)
.build();
let timeout = client.inner.config.timeout.expect("timeout configured");
let d = |secs: u64| std::time::Duration::from_secs(secs);
assert_eq!(timeout.connect, Some(d(5)), "last connect wins");
assert_eq!(timeout.read, Some(d(10)), "last read wins");
assert_eq!(
timeout.write,
Some(d(30)),
"unset phases keep earlier values"
);
assert_eq!(timeout.pool, Some(d(30)));
}
#[test]
fn client_builder_merge_timeout_without_prior_config() {
let client = Client::builder()
.merge_timeout(
Timeout::builder()
.connect(std::time::Duration::from_secs(5))
.build(),
)
.build();
let timeout = client.inner.config.timeout.expect("timeout configured");
assert_eq!(timeout.connect, Some(std::time::Duration::from_secs(5)));
assert_eq!(timeout.read, None);
}
#[cfg(any(feature = "proxy", feature = "http3"))]
#[test]
fn client_builder_danger_accept_invalid_certs_preserves_tls_config() {
let client = Client::builder()
.tls_config(crate::tls::TlsConfig::builder().sni(false).build())
.danger_accept_invalid_certs(true)
.build();
let tls = client
.inner
.config
.tls_config
.as_ref()
.expect("TLS config should be retained");
assert!(!tls.sni_enabled());
assert!(!tls.verify_certificate());
assert!(!tls.verify_hostname());
}
#[test]
#[cfg(feature = "tls-rustls")]
fn tls_root_store_paths_construct() {
let enabler =
crate::http_version::HttpVersionPolicyEnabler::from_policy(HttpVersionPolicy::Auto {
allow_http3: false,
});
let config = crate::tls::TlsConfig::default()
.build_rustls_config()
.expect("default TLS policy builds");
let _ = build_standard_connector(config, enabler);
}
#[test]
fn client_builder_http1_only() {
let client = Client::builder()
.http_version_policy(HttpVersionPolicy::Http1Only)
.build();
assert_eq!(
client.inner.config.http_version_policy,
HttpVersionPolicy::Http1Only
);
}
#[test]
fn client_builder_http2_auto() {
let client = Client::builder()
.http_version_policy(HttpVersionPolicy::Auto { allow_http3: false })
.build();
assert_eq!(
client.inner.config.http_version_policy,
HttpVersionPolicy::Auto { allow_http3: false }
);
}
#[test]
#[cfg(feature = "http2")]
fn client_builder_http2_only() {
let client = Client::builder()
.http_version_policy(HttpVersionPolicy::Http2Only)
.build();
assert_eq!(
client.inner.config.http_version_policy,
HttpVersionPolicy::Http2Only
);
}
#[test]
fn connector_builds_for_all_policies() {
for policy in [
HttpVersionPolicy::Http1Only,
HttpVersionPolicy::Auto { allow_http3: false },
#[cfg(feature = "http2")]
HttpVersionPolicy::Http2Only,
#[cfg(feature = "http3")]
HttpVersionPolicy::Http3Only,
] {
let enabler = crate::http_version::HttpVersionPolicyEnabler::from_policy(policy);
if !enabler.use_http3() {
#[cfg(feature = "tls-rustls")]
let config = crate::tls::TlsConfig::default()
.build_rustls_config()
.expect("default TLS policy builds");
#[cfg(feature = "tls-rustls")]
let _ = build_standard_connector(config, enabler);
}
}
}
#[cfg(feature = "http2")]
#[test]
fn custom_connector_alpn_matches_http_version_policy() {
let config = rustls::ClientConfig::builder()
.with_root_certificates(rustls::RootCertStore::empty())
.with_no_client_auth();
let h2_only = configure_tls_alpn(
config.clone(),
crate::http_version::HttpVersionPolicyEnabler::from_policy(
HttpVersionPolicy::Http2Only,
),
);
assert_eq!(h2_only.alpn_protocols, vec![b"h2".to_vec()]);
let auto = configure_tls_alpn(
config,
crate::http_version::HttpVersionPolicyEnabler::from_policy(HttpVersionPolicy::Auto {
allow_http3: false,
}),
);
assert_eq!(
auto.alpn_protocols,
vec![b"h2".to_vec(), b"http/1.1".to_vec()]
);
}
#[test]
fn parse_valid_urls() {
assert!(parse_url("https://example.com").is_ok());
assert!(parse_url("http://localhost:8080").is_ok());
}
#[test]
fn parse_invalid_schemes() {
assert!(parse_url("ftp://example.com").is_err());
assert!(parse_url("file:///tmp/test").is_err());
}
#[test]
fn parse_invalid_urls() {
assert!(parse_url("not a url").is_err());
}
#[test]
fn get_request_builder() {
let client = Client::new();
let builder = client.get("https://example.com").unwrap();
let req = builder.build().unwrap();
assert_eq!(*req.method(), Method::GET);
}
#[test]
fn apply_content_length_empty_body() {
let headers = Headers::new();
let body = crate::body::RequestBody::Empty;
let out = crate::pipeline::apply_content_length(headers, &body).unwrap();
assert_eq!(out.get("content-length").unwrap().to_str().unwrap(), "0");
}
#[test]
fn apply_content_length_bytes_body() {
let headers = Headers::new();
let body = crate::body::RequestBody::from(Bytes::from("hello"));
let out = crate::pipeline::apply_content_length(headers, &body).unwrap();
assert_eq!(out.get("content-length").unwrap().to_str().unwrap(), "5");
}
#[test]
fn apply_content_length_stream_known() {
let headers = Headers::new();
let stream = futures_util::stream::empty::<Result<Bytes>>();
let body = crate::body::RequestBody::from_stream(stream, Some(7));
let out = crate::pipeline::apply_content_length(headers, &body).unwrap();
assert_eq!(out.get("content-length").unwrap().to_str().unwrap(), "7");
}
#[test]
fn apply_content_length_stream_unknown() {
let headers = Headers::new();
let stream = futures_util::stream::empty::<Result<Bytes>>();
let body = crate::body::RequestBody::from_stream(stream, None);
let out = crate::pipeline::apply_content_length(headers, &body).unwrap();
assert!(out.get("content-length").is_none());
}
#[test]
fn apply_content_length_user_matches() {
let mut headers = Headers::new();
headers.insert("content-length", "5").unwrap();
let body = crate::body::RequestBody::from(Bytes::from("hello"));
let out = crate::pipeline::apply_content_length(headers, &body).unwrap();
assert_eq!(out.get("content-length").unwrap().to_str().unwrap(), "5");
}
#[test]
fn apply_content_length_user_mismatch_errors() {
let mut headers = Headers::new();
headers.insert("content-length", "10").unwrap();
let body = crate::body::RequestBody::from(Bytes::from("hello"));
let err = crate::pipeline::apply_content_length(headers, &body).unwrap_err();
assert_eq!(err.kind(), "request_build");
}
#[test]
fn apply_content_length_rejects_invalid_value() {
let mut headers = Headers::new();
headers.insert("content-length", "not-a-number").unwrap();
let body = crate::body::RequestBody::from(Bytes::from("hello"));
let err = crate::pipeline::apply_content_length(headers, &body).unwrap_err();
assert_eq!(err.kind(), "invalid_header_value");
}
#[test]
fn apply_content_length_rejects_unknown_stream_override() {
let mut headers = Headers::new();
headers.insert("content-length", "5").unwrap();
let stream = futures_util::stream::empty::<Result<Bytes>>();
let body = crate::body::RequestBody::from_stream(stream, None);
let err = crate::pipeline::apply_content_length(headers, &body).unwrap_err();
assert_eq!(err.kind(), "request_build");
}
#[test]
fn parse_url_rejects_userinfo_without_echoing_credentials() {
let err = parse_url("https://user:secret@example.com").unwrap_err();
assert_eq!(err.kind(), "invalid_url");
assert!(!err.to_string().contains("secret"));
}
#[cfg(feature = "proxy")]
#[tokio::test]
async fn proxy_auth_conflict_with_header() {
let proxy = Proxy::all("http://proxy.example:8080")
.unwrap()
.auth(ProxyAuth::basic("user", "pass").unwrap());
let client = Client::builder().proxy(proxy).build();
let request = client
.get("http://destination.example")
.unwrap()
.header("proxy-authorization", "Basic dXNlcjpwYXNz")
.build()
.unwrap();
let err = client.send(request).await.unwrap_err();
assert_eq!(err.kind(), "conflicting_auth");
assert!(err.to_string().contains("Proxy-Authorization"));
}
#[cfg(feature = "proxy")]
#[tokio::test]
async fn proxy_auth_no_conflict_without_header() {
let proxy = Proxy::all("http://proxy.example:8080")
.unwrap()
.auth(ProxyAuth::basic("user", "pass").unwrap());
let client = Client::builder().proxy(proxy).build();
let request = client
.get("http://destination.example")
.unwrap()
.build()
.unwrap();
let err = client.send(request).await.unwrap_err();
assert_ne!(err.kind(), "conflicting_auth");
}
#[cfg(feature = "proxy")]
#[tokio::test]
async fn proxy_auth_no_conflict_with_header_only() {
let proxy = Proxy::all("http://proxy.example:8080").unwrap();
let client = Client::builder().proxy(proxy).build();
let request = client
.get("http://destination.example")
.unwrap()
.header("proxy-authorization", "Basic dXNlcjpwYXNz")
.build()
.unwrap();
let err = client.send(request).await.unwrap_err();
assert_ne!(err.kind(), "conflicting_auth");
}
}