use std::sync::Arc;
use std::time::Duration;
#[cfg(any(
feature = "transport-http1",
feature = "transport-http2",
feature = "advanced-routing"
))]
use crate::transport::hyper_client::{build_hyper_client, HyperClientPolicy};
#[cfg(feature = "advanced-routing")]
use crate::transport::hyper_client::{
BoundedClientCache, RESOLVED_CLIENT_CACHE_MAX_ENTRIES, SNI_CLIENT_CACHE_MAX_ENTRIES,
};
#[cfg(feature = "proxy")]
use crate::transport::hyper_client::{
CONNECT_CLIENT_CACHE_MAX_ENTRIES, FORWARD_CLIENT_CACHE_MAX_ENTRIES,
SOCKS_CLIENT_CACHE_MAX_ENTRIES,
};
#[cfg(feature = "high-level-url")]
use http::Method;
#[cfg(any(feature = "advanced-routing", feature = "proxy"))]
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;
#[cfg(feature = "redirects")]
use crate::redirect::RedirectPolicy;
#[cfg(feature = "high-level-url")]
use crate::request::{Request, RequestBuilder};
#[cfg(feature = "high-level-url")]
use crate::response::Response;
#[cfg(feature = "logical-retry")]
use crate::retry::RetryPolicy;
use crate::timeout::Timeout;
#[cfg(feature = "advanced-routing")]
use crate::transport::dialer::Dialer;
#[cfg(any(
feature = "transport-http1",
feature = "transport-http2",
feature = "advanced-routing"
))]
use crate::transport::lifecycle::LifecycleConfig;
use crate::transport::lifecycle::{PhysicalConnectionPolicy, TransportIoTimeout};
use crate::transport::Connector;
use crate::transport_hints::NativeRequestOptions;
#[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>,
#[cfg(feature = "redirects")]
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>,
#[cfg(feature = "logical-retry")]
pub(crate) retry: Option<RetryPolicy>,
pub(crate) retry_canceled_requests: bool,
#[cfg(feature = "advanced-routing")]
pub(crate) dialer: Option<Arc<dyn Dialer>>,
#[cfg(feature = "advanced-routing")]
pub(crate) uds_configured: bool,
#[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);
#[cfg(feature = "redirects")]
debug.field("redirect", &self.redirect);
debug.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);
#[cfg(feature = "logical-retry")]
debug.field("retry", &self.retry);
debug.field("retry_canceled_requests", &self.retry_canceled_requests);
#[cfg(feature = "advanced-routing")]
debug
.field("dialer", &self.dialer.as_ref().map(|_| "configured"))
.field("uds_configured", &self.uds_configured);
debug
.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,
#[cfg(feature = "redirects")]
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,
#[cfg(feature = "logical-retry")]
retry: None,
retry_canceled_requests: true,
#[cfg(feature = "advanced-routing")]
dialer: None,
#[cfg(feature = "advanced-routing")]
uds_configured: false,
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()
}
}
#[cfg(feature = "advanced-routing")]
#[derive(Clone, PartialEq, Eq, Hash)]
pub(crate) struct ResolvedRouteKey {
origin: String,
addresses: Arc<[std::net::SocketAddr]>,
sni_hostname: Option<String>,
}
#[cfg(feature = "advanced-routing")]
impl ResolvedRouteKey {
pub(crate) fn from_origin(
origin: &crate::http_origin::HttpOrigin,
target: &crate::transport_hints::ResolvedTarget,
sni_hostname: Option<&str>,
) -> Self {
Self {
origin: origin.origin_string(),
addresses: target.addresses_shared(),
sni_hostname: sni_hostname.map(str::to_owned),
}
}
#[cfg(all(feature = "high-level-url", any(test, feature = "test-util")))]
#[allow(dead_code)]
pub(crate) fn new(
origin_url: &url::Url,
target: &crate::transport_hints::ResolvedTarget,
sni_hostname: Option<&str>,
) -> Self {
match crate::http_origin::HttpOrigin::from_url(origin_url) {
Some(origin) => Self::from_origin(&origin, target, sni_hostname),
None => Self {
origin: origin_url.origin().ascii_serialization(),
addresses: target.addresses_shared(),
sni_hostname: sni_hostname.map(str::to_owned),
},
}
}
}
pub(crate) struct ClientInner {
#[cfg(any(feature = "transport-http1", feature = "transport-http2"))]
pub(crate) hyper_client: Option<crate::transport::TimeoutHyperClient>,
#[cfg(feature = "advanced-routing")]
pub(crate) custom_client: Option<crate::transport::TimeoutCustomClient>,
#[cfg(feature = "tls-rustls")]
pub(crate) tls_config_error: Option<String>,
#[cfg(feature = "advanced-routing")]
pub(crate) direct_client: Option<crate::transport::TimeoutDirectClient>,
#[cfg(feature = "advanced-routing")]
pub(crate) direct_connector_config:
Option<crate::transport::direct_connector::DirectConnectorConfig>,
#[cfg(feature = "advanced-routing")]
pub(crate) sni_clients:
Mutex<BoundedClientCache<String, crate::transport::TimeoutDirectClient>>,
#[cfg(feature = "advanced-routing")]
pub(crate) sni_custom_clients:
Mutex<BoundedClientCache<String, crate::transport::TimeoutCustomClient>>,
#[cfg(feature = "advanced-routing")]
pub(crate) resolved_clients:
Mutex<BoundedClientCache<ResolvedRouteKey, crate::transport::TimeoutDirectClient>>,
#[cfg(unix)]
#[cfg(feature = "advanced-routing")]
pub(crate) uds_client: Option<crate::transport::TimeoutUdsClient>,
#[cfg(feature = "proxy")]
pub(crate) socks_clients: Mutex<
BoundedClientCache<
crate::transport::socks::SocksRouteKey,
crate::transport::TimeoutSocksClient,
>,
>,
#[cfg(feature = "proxy")]
pub(crate) forward_clients: Mutex<
BoundedClientCache<
crate::transport::proxy::ForwardRouteKey,
crate::transport::TimeoutForwardClient,
>,
>,
#[cfg(feature = "proxy")]
pub(crate) connect_clients: Mutex<
BoundedClientCache<
crate::transport::connect::ConnectRouteKey,
crate::transport::TimeoutConnectClient,
>,
>,
pub(crate) config: ClientConfig,
pub(crate) pool: Pool,
pub(crate) transport_metrics: Arc<crate::transport::metrics::TransportMetrics>,
#[cfg(any(
feature = "transport-http1",
feature = "transport-http2",
feature = "advanced-routing"
))]
pub(crate) lifecycle: Arc<LifecycleConfig>,
#[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>,
}
#[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(feature = "advanced-routing")]
pub(crate) async fn resolved_client(
&self,
origin: &crate::http_origin::HttpOrigin,
target: &crate::transport_hints::ResolvedTarget,
sni_hostname: Option<&str>,
) -> Result<crate::transport::TimeoutDirectClient> {
let key = ResolvedRouteKey::from_origin(origin, target, sni_hostname);
let mut clients = self.resolved_clients.lock().await;
if let Some(client) = clients.get(&key) {
return Ok(client.clone());
}
let client = Self::build_resolved_client(
&self.config,
self.direct_connector_config.as_ref(),
&self.transport_metrics,
&self.pool,
&self.lifecycle,
target,
sni_hostname,
)?;
clients.insert(key, client.clone());
Ok(client)
}
#[cfg(feature = "advanced-routing")]
#[allow(clippy::too_many_arguments)]
fn build_resolved_client(
config: &ClientConfig,
direct_connector_config: Option<&crate::transport::direct_connector::DirectConnectorConfig>,
transport_metrics: &Arc<crate::transport::metrics::TransportMetrics>,
pool: &Pool,
lifecycle: &Arc<LifecycleConfig>,
target: &crate::transport_hints::ResolvedTarget,
sni_hostname: Option<&str>,
) -> Result<crate::transport::TimeoutDirectClient> {
let connect_timeout = config.timeout.as_ref().and_then(|t| t.connect);
#[cfg(feature = "tls-rustls")]
let tls_connector = {
let tls_config = 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(
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 = direct_connector_config.cloned().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,
transport_metrics.clone(),
)
.with_resolved_target(target);
if let Some(sni_hostname) = sni_hostname {
connector = connector.with_sni(sni_hostname.to_owned());
}
let policy = HyperClientPolicy::cached_route(
config.retry_canceled_requests,
pool.idle_timeout(),
pool.max_idle_per_host(),
crate::http_version::HttpVersionPolicyEnabler::from_policy(config.http_version_policy),
);
Ok(build_hyper_client(
connector,
&policy,
connect_timeout,
lifecycle,
))
}
#[cfg(feature = "advanced-routing")]
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);
let enabler = crate::http_version::HttpVersionPolicyEnabler::from_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, enabler);
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 policy = HyperClientPolicy::cached_route(
self.config.retry_canceled_requests,
self.pool.idle_timeout(),
self.pool.max_idle_per_host(),
enabler,
);
let client = build_hyper_client(sni_connector, &policy, connect_timeout, &self.lifecycle);
clients.insert(sni_hostname.to_owned(), client.clone());
Ok(client)
}
#[cfg(feature = "advanced-routing")]
pub(crate) async fn sni_custom_client(
&self,
sni_hostname: &str,
) -> Result<crate::transport::TimeoutCustomClient> {
let mut clients = self.sni_custom_clients.lock().await;
if let Some(client) = clients.get(sni_hostname) {
return Ok(client.clone());
}
let dialer = self
.config
.dialer
.clone()
.ok_or_else(|| Error::Unsupported("custom dialer is not configured".into()))?;
#[cfg(feature = "tls-rustls")]
let tls_config = self
.config
.tls_config
.clone()
.unwrap_or_default()
.build_rustls_config()
.map_err(|error| Error::Tls(format!("failed to build TLS config: {error}")))?;
#[cfg(not(feature = "tls-rustls"))]
let tls_config = ();
let connector = build_custom_connector(
tls_config,
dialer,
crate::http_version::HttpVersionPolicyEnabler::from_policy(
self.config.http_version_policy,
),
Some(sni_hostname),
)?;
let policy = HyperClientPolicy::cached_route(
self.config.retry_canceled_requests,
self.pool.idle_timeout(),
self.pool.max_idle_per_host(),
crate::http_version::HttpVersionPolicyEnabler::from_policy(
self.config.http_version_policy,
),
);
let client = build_hyper_client(
connector,
&policy,
self.config
.timeout
.as_ref()
.and_then(|timeout| timeout.connect),
&self.lifecycle,
);
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,
target: Option<&crate::transport_hints::ResolvedTarget>,
) -> Result<crate::transport::TimeoutSocksClient> {
let key = crate::transport::socks::SocksRouteKey::from_proxy(proxy, target)?;
let mut clients = self.socks_clients.lock().await;
if let Some(client) = clients.get(&key) {
return Ok(client.clone());
}
let enabler = crate::http_version::HttpVersionPolicyEnabler::from_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, enabler);
let connector = crate::transport::socks::SocksConnector::new(
proxy.clone(),
Some(tokio_rustls::TlsConnector::from(Arc::new(tls_config))),
None,
target,
);
let policy = HyperClientPolicy::cached_route(
self.config.retry_canceled_requests,
self.pool.idle_timeout(),
self.pool.max_idle_per_host(),
enabler,
);
let client = build_hyper_client(
connector,
&policy,
self.config
.timeout
.as_ref()
.and_then(|timeout| timeout.connect),
&self.lifecycle,
);
clients.insert(key, client.clone());
Ok(client)
}
#[cfg(any(feature = "transport-http1", feature = "transport-http2"))]
pub(crate) async fn forward_client(
&self,
proxy: &crate::proxy::ProxyConfig,
origin: &url::Url,
connect_timeout: Option<Duration>,
) -> Result<crate::transport::TimeoutForwardClient> {
let proxy_tls_timeout = connect_timeout;
let key = crate::transport::proxy::ForwardRouteKey::new(
proxy,
origin,
connect_timeout,
proxy_tls_timeout,
);
let mut clients = self.forward_clients.lock().await;
if let Some(client) = clients.get(&key) {
return Ok(client.clone());
}
let connector = crate::transport::proxy::ForwardProxyConnector::new(
proxy.clone(),
connect_timeout,
proxy_tls_timeout,
self.transport_metrics.clone(),
);
let policy = HyperClientPolicy::forward_route(
self.config.retry_canceled_requests,
self.pool.idle_timeout(),
self.pool.max_idle_per_host(),
);
let client = build_hyper_client(connector, &policy, connect_timeout, &self.lifecycle);
clients.insert(key, client.clone());
Ok(client)
}
#[cfg(any(feature = "transport-http1", feature = "transport-http2"))]
pub(crate) async fn connect_client(
&self,
proxy: &crate::proxy::ProxyConfig,
origin: &url::Url,
transport_hints: &crate::transport_hints::TransportHints,
target: Option<std::net::SocketAddr>,
connect_timeout: Option<Duration>,
) -> Result<crate::transport::TimeoutConnectClient> {
let key = crate::transport::connect::ConnectRouteKey::new(
proxy,
origin,
target,
self.config.tls_config.as_ref(),
transport_hints.sni_hostname.as_deref(),
self.config.http_version_policy,
connect_timeout,
connect_timeout,
);
let mut clients = self.connect_clients.lock().await;
if let Some(client) = clients.get(&key) {
return Ok(client.clone());
}
let connector = crate::transport::connect::ConnectProxyConnector::new(
origin.clone(),
proxy.clone(),
transport_hints,
target,
self.config.tls_config.clone(),
connect_timeout,
connect_timeout,
connect_timeout,
self.config.http_version_policy,
self.transport_metrics.clone(),
);
let policy = HyperClientPolicy::cached_route(
self.config.retry_canceled_requests,
self.pool.idle_timeout(),
self.pool.max_idle_per_host(),
crate::http_version::HttpVersionPolicyEnabler::from_policy(
self.config.http_version_policy,
),
);
let client = build_hyper_client(connector, &policy, connect_timeout, &self.lifecycle);
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()
}
#[cfg(feature = "high-level-url")]
pub fn get(&self, url: &str) -> Result<RequestBuilder> {
self.request(Method::GET, url)
}
#[cfg(feature = "high-level-url")]
pub fn post(&self, url: &str) -> Result<RequestBuilder> {
self.request(Method::POST, url)
}
#[cfg(feature = "high-level-url")]
pub fn put(&self, url: &str) -> Result<RequestBuilder> {
self.request(Method::PUT, url)
}
#[cfg(feature = "high-level-url")]
pub fn patch(&self, url: &str) -> Result<RequestBuilder> {
self.request(Method::PATCH, url)
}
#[cfg(feature = "high-level-url")]
pub fn delete(&self, url: &str) -> Result<RequestBuilder> {
self.request(Method::DELETE, url)
}
#[cfg(feature = "high-level-url")]
pub fn head(&self, url: &str) -> Result<RequestBuilder> {
self.request(Method::HEAD, url)
}
#[cfg(feature = "high-level-url")]
pub fn options(&self, url: &str) -> Result<RequestBuilder> {
self.request(Method::OPTIONS, url)
}
#[cfg(feature = "high-level-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
}
#[cfg(feature = "high-level-url")]
pub(crate) async fn send(&self, request: Request) -> Result<Response> {
#[cfg(feature = "logical-retry")]
{
Box::pin(crate::pipeline::send_with_retry(self, request)).await
}
#[cfg(all(not(feature = "logical-retry"), feature = "redirects"))]
{
Box::pin(crate::pipeline::send_with_redirects(self, request)).await
}
#[cfg(all(not(feature = "logical-retry"), not(feature = "redirects")))]
{
Box::pin(crate::pipeline::send_lean(self, request)).await
}
}
#[cfg(feature = "high-level-url")]
pub async fn send_detailed(
&self,
mut request: Request,
) -> std::result::Result<Response, crate::RequestFailure> {
let context = crate::error::RequestFailureContext::new();
context.clear();
request.set_failure_context(Some(context.clone()));
#[cfg(feature = "logical-retry")]
let result = Box::pin(crate::pipeline::send_with_retry(self, request)).await;
#[cfg(all(not(feature = "logical-retry"), feature = "redirects"))]
let result = Box::pin(crate::pipeline::send_with_redirects(self, request)).await;
#[cfg(all(not(feature = "logical-retry"), not(feature = "redirects")))]
let result = Box::pin(crate::pipeline::send_lean(self, request)).await;
match result {
Ok(response) => Ok(response),
Err(error) => Err(crate::RequestFailure::from_context(error, &context)),
}
}
#[cfg(feature = "high-level-url")]
pub(crate) async fn send_single_request(
&self,
request: Request,
timeout: &Timeout,
) -> Result<Response> {
crate::pipeline::send_single_request(&self.inner, request, timeout).await
}
pub async fn execute_http_body<B>(
&self,
request: http::Request<B>,
options: NativeRequestOptions,
) -> Result<http::Response<crate::NativeResponseBody>>
where
B: http_body::Body<Data = bytes::Bytes> + Send + 'static,
B::Error: std::error::Error + Send + Sync + 'static,
{
crate::pipeline::send_native_http_body(&self.inner, request, options).await
}
pub async fn execute_http_body_default<B>(
&self,
request: http::Request<B>,
) -> Result<http::Response<crate::NativeResponseBody>>
where
B: http_body::Body<Data = bytes::Bytes> + Send + 'static,
B::Error: std::error::Error + Send + Sync + 'static,
{
self.execute_http_body(request, NativeRequestOptions::default())
.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>,
#[cfg(feature = "redirects")]
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>,
#[cfg(feature = "logical-retry")]
retry: Option<RetryPolicy>,
retry_canceled_requests: bool,
#[cfg(feature = "advanced-routing")]
dialer: Option<Arc<dyn Dialer>>,
physical_connection_policy: PhysicalConnectionPolicy,
transport_io_timeout: TransportIoTimeout,
http_version_policy: HttpVersionPolicy,
#[cfg(feature = "advanced-routing")]
direct_connector_config: Option<crate::transport::direct_connector::DirectConnectorConfig>,
#[cfg(feature = "advanced-routing")]
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,
#[cfg(feature = "redirects")]
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,
#[cfg(feature = "logical-retry")]
retry: None,
retry_canceled_requests: true,
#[cfg(feature = "advanced-routing")]
dialer: None,
physical_connection_policy: PhysicalConnectionPolicy::default(),
transport_io_timeout: TransportIoTimeout::default(),
http_version_policy: HttpVersionPolicy::default(),
#[cfg(feature = "advanced-routing")]
direct_connector_config: None,
#[cfg(feature = "advanced-routing")]
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
}
#[cfg(feature = "redirects")]
#[must_use]
pub fn follow_redirects(mut self, follow: bool) -> Self {
self.redirect.follow = follow;
self
}
#[cfg(feature = "redirects")]
#[must_use]
pub fn max_redirects(mut self, max: usize) -> Self {
self.redirect.max_redirects = max;
self
}
#[cfg(feature = "redirects")]
#[must_use]
pub fn redirect_policy(mut self, policy: RedirectPolicy) -> Self {
self.redirect = policy;
self
}
#[cfg(feature = "redirects")]
#[must_use]
pub fn redirect_downgrade_policy(
mut self,
policy: crate::redirect::RedirectDowngradePolicy,
) -> Self {
self.redirect.downgrade = 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")]
pub fn proxy_environment(
mut self,
env: &crate::proxy::ProxyEnvironment,
) -> crate::error::Result<Self> {
for proxy in env.client_proxies()? {
self.environment_proxies.push(proxy);
}
Ok(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
}
#[cfg(feature = "logical-retry")]
#[must_use]
pub fn retry(mut self, policy: RetryPolicy) -> Self {
self.retry = Some(policy);
self
}
#[must_use]
pub fn retry_canceled_requests(mut self, enabled: bool) -> Self {
self.retry_canceled_requests = enabled;
self
}
#[cfg(feature = "advanced-routing")]
#[must_use]
pub fn dialer<D>(mut self, dialer: D) -> Self
where
D: Dialer,
{
self.dialer = Some(Arc::new(dialer));
self
}
#[must_use]
pub fn physical_connection_policy(mut self, policy: PhysicalConnectionPolicy) -> Self {
self.physical_connection_policy = policy;
self
}
#[must_use]
pub fn transport_io_timeout(mut self, timeout: TransportIoTimeout) -> Self {
self.transport_io_timeout = timeout;
self
}
#[must_use]
pub fn http_version_policy(mut self, policy: HttpVersionPolicy) -> Self {
self.http_version_policy = policy;
self
}
#[cfg(feature = "advanced-routing")]
#[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
}
#[cfg(feature = "advanced-routing")]
#[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
}
#[cfg(feature = "advanced-routing")]
#[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 = "transport-http1",
feature = "transport-http2",
feature = "advanced-routing"
))]
use crate::http_version::HttpVersionPolicyEnabler;
#[cfg(any(
feature = "transport-http1",
feature = "transport-http2",
feature = "advanced-routing"
))]
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(any(
feature = "transport-http1",
feature = "transport-http2",
feature = "advanced-routing"
))]
let lifecycle = Arc::new(LifecycleConfig::from_policy(
self.physical_connection_policy,
self.transport_io_timeout,
transport_metrics.clone(),
));
#[cfg(any(
feature = "transport-http1",
feature = "transport-http2",
feature = "advanced-routing"
))]
let persistent_policy = HyperClientPolicy::persistent(
self.retry_canceled_requests,
pool_config.idle_timeout,
pool_config.effective_max_idle_per_host(),
enabler,
);
#[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);
Some(build_hyper_client(
https,
&persistent_policy,
connect_timeout,
&lifecycle,
))
} else {
None
};
#[cfg(all(
not(feature = "tls-rustls"),
any(feature = "transport-http1", feature = "transport-http2")
))]
let hyper_client = if matches!(
self.http_version_policy,
crate::HttpVersionPolicy::Http3Only
) {
None
} else {
let connector = build_standard_connector(enabler);
let connect_timeout = self.timeout.as_ref().and_then(|t| t.connect);
Some(build_hyper_client(
connector,
&persistent_policy,
connect_timeout,
&lifecycle,
))
};
#[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(feature = "advanced-routing")]
let stored_direct_config = self.direct_connector_config.clone();
#[cfg(feature = "advanced-routing")]
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(),
);
Some(build_hyper_client(
direct_connector,
&persistent_policy,
connect_timeout,
&lifecycle,
))
} else {
None
};
#[cfg(all(not(unix), feature = "advanced-routing"))]
let _ = &self.uds_path;
#[cfg(all(unix, feature = "advanced-routing"))]
let uds_client = self.uds_path.clone().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 connect_timeout = self.timeout.as_ref().and_then(|timeout| timeout.connect);
build_hyper_client(connector, &persistent_policy, connect_timeout, &lifecycle)
});
#[cfg(feature = "advanced-routing")]
let custom_client = if let Some(dialer) = self.dialer.clone() {
#[cfg(feature = "tls-rustls")]
let custom_config = self
.tls_config
.clone()
.unwrap_or_default()
.build_rustls_config()
.ok();
#[cfg(not(feature = "tls-rustls"))]
let custom_config = Some(());
custom_config.and_then(|custom_config| {
let connector =
build_custom_connector(custom_config, dialer, enabler, None).ok()?;
let connect_timeout = self.timeout.as_ref().and_then(|timeout| timeout.connect);
Some(build_hyper_client(
connector,
&persistent_policy,
connect_timeout,
&lifecycle,
))
})
} else {
None
};
let config = ClientConfig {
default_headers: self.default_headers,
user_agent: self.user_agent,
timeout: self.timeout,
#[cfg(feature = "redirects")]
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,
#[cfg(feature = "logical-retry")]
retry: self.retry,
retry_canceled_requests: self.retry_canceled_requests,
#[cfg(feature = "advanced-routing")]
dialer: self.dialer,
#[cfg(feature = "advanced-routing")]
uds_configured: self.uds_path.is_some(),
http_version_policy: self.http_version_policy,
};
let pool = Pool::new(pool_config);
Client {
inner: Arc::new(ClientInner {
#[cfg(any(feature = "transport-http1", feature = "transport-http2"))]
hyper_client,
#[cfg(feature = "advanced-routing")]
custom_client,
#[cfg(feature = "tls-rustls")]
tls_config_error,
#[cfg(feature = "advanced-routing")]
direct_client,
#[cfg(feature = "advanced-routing")]
direct_connector_config: stored_direct_config,
#[cfg(feature = "advanced-routing")]
sni_clients: Mutex::new(BoundedClientCache::new(SNI_CLIENT_CACHE_MAX_ENTRIES)),
#[cfg(feature = "advanced-routing")]
sni_custom_clients: Mutex::new(BoundedClientCache::new(
SNI_CLIENT_CACHE_MAX_ENTRIES,
)),
#[cfg(feature = "advanced-routing")]
resolved_clients: Mutex::new(BoundedClientCache::new(
RESOLVED_CLIENT_CACHE_MAX_ENTRIES,
)),
#[cfg(all(unix, feature = "advanced-routing"))]
uds_client,
#[cfg(feature = "proxy")]
socks_clients: Mutex::new(BoundedClientCache::new(SOCKS_CLIENT_CACHE_MAX_ENTRIES)),
#[cfg(feature = "proxy")]
forward_clients: Mutex::new(BoundedClientCache::new(
FORWARD_CLIENT_CACHE_MAX_ENTRIES,
)),
#[cfg(feature = "proxy")]
connect_clients: Mutex::new(BoundedClientCache::new(
CONNECT_CLIENT_CACHE_MAX_ENTRIES,
)),
config,
pool,
transport_metrics,
#[cfg(any(
feature = "transport-http1",
feature = "transport-http2",
feature = "advanced-routing"
))]
lifecycle,
#[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 {
build_standard_connector_with_resolver(
hyper_util::client::legacy::connect::dns::GaiResolver::new(),
enabler,
)
}
#[cfg(not(feature = "tls-rustls"))]
fn build_standard_connector_with_resolver<R>(
resolver: R,
enabler: crate::http_version::HttpVersionPolicyEnabler,
) -> hyper_util::client::legacy::connect::HttpConnector<
crate::transport::standard_resolver::ClassifyingResolver<R>,
>
where
R: tower_service::Service<hyper_util::client::legacy::connect::dns::Name>
+ Clone
+ Send
+ Sync
+ 'static,
R::Response: Iterator<Item = std::net::SocketAddr>,
R::Error: Into<Box<dyn std::error::Error + Send + Sync>>,
R::Future: Send + 'static,
{
let _ = enabler;
let mut connector = hyper_util::client::legacy::connect::HttpConnector::new_with_resolver(
crate::transport::standard_resolver::ClassifyingResolver::new(resolver),
);
connector.enforce_http(true);
connector
}
#[cfg(feature = "tls-rustls")]
fn build_standard_connector(
config: rustls::ClientConfig,
enabler: crate::http_version::HttpVersionPolicyEnabler,
) -> Connector {
build_standard_connector_with_resolver(
config,
enabler,
hyper_util::client::legacy::connect::dns::GaiResolver::new(),
)
}
#[cfg(feature = "tls-rustls")]
fn build_standard_connector_with_resolver<R>(
mut config: rustls::ClientConfig,
enabler: crate::http_version::HttpVersionPolicyEnabler,
resolver: R,
) -> hyper_rustls::HttpsConnector<
hyper_util::client::legacy::connect::HttpConnector<
crate::transport::standard_resolver::ClassifyingResolver<R>,
>,
>
where
R: tower_service::Service<hyper_util::client::legacy::connect::dns::Name>
+ Clone
+ Send
+ Sync
+ 'static,
R::Response: Iterator<Item = std::net::SocketAddr>,
R::Error: Into<Box<dyn std::error::Error + Send + Sync>>,
R::Future: Send + 'static,
{
config.alpn_protocols.clear();
let mut http = hyper_util::client::legacy::connect::HttpConnector::new_with_resolver(
crate::transport::standard_resolver::ClassifyingResolver::new(resolver),
);
http.enforce_http(false);
let builder = hyper_rustls::HttpsConnectorBuilder::new()
.with_tls_config(config)
.https_or_http();
#[cfg(feature = "transport-http2")]
{
match (enabler.enable_http1(), enabler.enable_http2()) {
(true, true) => builder.enable_http1().enable_http2().wrap_connector(http),
(true | false, false) => builder.enable_http1().wrap_connector(http),
(false, true) => builder.enable_http2().wrap_connector(http),
}
}
#[cfg(not(feature = "transport-http2"))]
{
let _ = enabler;
builder.enable_http1().wrap_connector(http)
}
}
#[cfg(all(feature = "tls-rustls", feature = "advanced-routing"))]
fn build_custom_connector(
config: rustls::ClientConfig,
dialer: Arc<dyn Dialer>,
enabler: crate::http_version::HttpVersionPolicyEnabler,
sni_hostname: Option<&str>,
) -> Result<crate::transport::CustomConnector> {
let config = configure_tls_alpn(config, enabler);
let resolver: Arc<dyn hyper_rustls::ResolveServerName + Send + Sync> =
if let Some(sni_hostname) = sni_hostname {
let server_name = rustls::pki_types::ServerName::try_from(sni_hostname.to_owned())
.map_err(|error| Error::Tls(format!("invalid SNI hostname: {error}")))?;
Arc::new(hyper_rustls::FixedServerNameResolver::new(server_name))
} else {
Arc::new(hyper_rustls::DefaultServerNameResolver::default())
};
Ok(hyper_rustls::HttpsConnector::new(
crate::transport::dialer::DialerConnector::new(dialer),
Arc::new(config),
false,
resolver,
))
}
#[cfg(all(not(feature = "tls-rustls"), feature = "advanced-routing"))]
fn build_custom_connector(
_config: (),
dialer: Arc<dyn Dialer>,
_enabler: crate::http_version::HttpVersionPolicyEnabler,
_sni_hostname: Option<&str>,
) -> Result<crate::transport::CustomConnector> {
Ok(crate::transport::dialer::DialerConnector::new(dialer))
}
impl Default for ClientBuilder {
fn default() -> Self {
Self::new()
}
}
#[cfg(feature = "high-level-url")]
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;
#[cfg(any(feature = "transport-http1", feature = "transport-http2"))]
use hyper_util::rt::TokioExecutor;
#[cfg(any(feature = "transport-http1", feature = "transport-http2"))]
use std::future::{ready, Ready};
#[cfg(any(feature = "transport-http1", feature = "transport-http2"))]
use std::net::SocketAddr;
#[cfg(any(feature = "transport-http1", feature = "transport-http2"))]
use std::task::{Context, Poll};
#[cfg(any(feature = "transport-http1", feature = "transport-http2"))]
use tower_service::Service;
#[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}"
);
}
#[cfg(feature = "high-level-url")]
#[test]
fn client_default() {
let _client = Client::default();
}
#[cfg(feature = "high-level-url")]
#[test]
fn client_builder() {
let _client = Client::builder().user_agent("test-agent").build();
}
#[cfg(any(feature = "transport-http1", feature = "transport-http2"))]
#[cfg(feature = "high-level-url")]
#[tokio::test]
async fn standard_connector_preserves_resolver_failure_for_detailed_mapping() {
#[derive(Clone, Copy)]
struct FailingResolver;
impl Service<hyper_util::client::legacy::connect::dns::Name> for FailingResolver {
type Response = std::vec::IntoIter<SocketAddr>;
type Error = std::io::Error;
type Future = Ready<std::result::Result<Self::Response, Self::Error>>;
fn poll_ready(
&mut self,
_: &mut Context<'_>,
) -> Poll<std::result::Result<(), Self::Error>> {
Poll::Ready(Ok(()))
}
fn call(&mut self, _: hyper_util::client::legacy::connect::dns::Name) -> Self::Future {
ready(Err(std::io::Error::new(
std::io::ErrorKind::NotFound,
"synthetic standard resolver failure",
)))
}
}
let enabler = crate::http_version::HttpVersionPolicyEnabler::from_policy(
HttpVersionPolicy::Http1Only,
);
#[cfg(feature = "tls-rustls")]
let connector = build_standard_connector_with_resolver(
rustls::ClientConfig::builder()
.with_root_certificates(rustls::RootCertStore::empty())
.with_no_client_auth(),
enabler,
FailingResolver,
);
#[cfg(not(feature = "tls-rustls"))]
let connector = build_standard_connector_with_resolver(FailingResolver, enabler);
let client =
hyper_util::client::legacy::Client::builder(TokioExecutor::new()).build(connector);
#[cfg(feature = "tls-rustls")]
let uri = "https://synthetic.example/";
#[cfg(not(feature = "tls-rustls"))]
let uri = "http://synthetic.example/";
let request = http::Request::get(uri)
.body(http_body_util::Empty::<Bytes>::new())
.expect("synthetic request is valid");
let error = client
.request(request)
.await
.expect_err("synthetic resolver should fail");
let context = crate::error::RequestFailureContext::new();
let mapped = crate::transport::direct::map_send_error_with_context(error, Some(&context));
assert_eq!(mapped.kind(), "hyper_client");
let failure = crate::error::RequestFailure::from_context(mapped, &context);
assert_eq!(
failure.network_failure_kind(),
Some(crate::error::NetworkFailureKind::Dns)
);
}
#[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 = "transport-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
);
}
#[cfg(feature = "high-level-url")]
#[test]
fn connector_builds_for_all_policies() {
for policy in [
HttpVersionPolicy::Http1Only,
HttpVersionPolicy::Auto { allow_http3: false },
#[cfg(feature = "transport-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 = "transport-http2")]
#[cfg(feature = "high-level-url")]
#[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()]
);
}
#[cfg(feature = "high-level-url")]
#[test]
fn parse_valid_urls() {
assert!(parse_url("https://example.com").is_ok());
assert!(parse_url("http://localhost:8080").is_ok());
}
#[cfg(feature = "high-level-url")]
#[test]
fn parse_invalid_schemes() {
assert!(parse_url("ftp://example.com").is_err());
assert!(parse_url("file:///tmp/test").is_err());
}
#[cfg(feature = "high-level-url")]
#[test]
fn parse_invalid_urls() {
assert!(parse_url("not a url").is_err());
}
#[cfg(feature = "high-level-url")]
#[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);
}
#[cfg(feature = "high-level-url")]
#[test]
fn hyper_canceled_request_retry_defaults_on_and_is_independently_configurable() {
assert!(Client::new().inner.config.retry_canceled_requests);
let strict = Client::builder().retry_canceled_requests(false).build();
assert!(!strict.inner.config.retry_canceled_requests);
#[cfg(feature = "logical-retry")]
assert!(strict.inner.config.retry.is_none());
}
#[cfg(feature = "high-level-url")]
#[test]
fn physical_policy_and_transport_io_timeout_are_separate_from_logical_pooling() {
let client = Client::builder()
.physical_connection_policy(PhysicalConnectionPolicy {
max_live: Some(2),
admission_timeout: Some(Duration::from_secs(1)),
})
.transport_io_timeout(TransportIoTimeout {
read: Some(Duration::from_secs(2)),
write: Some(Duration::from_secs(3)),
})
.build();
assert_eq!(
client.inner.lifecycle.admission_timeout,
Some(Duration::from_secs(1))
);
assert_eq!(
client.inner.lifecycle.io_timeout.read,
Some(Duration::from_secs(2))
);
assert_eq!(
client.inner.lifecycle.io_timeout.write,
Some(Duration::from_secs(3))
);
}
#[cfg(feature = "high-level-url")]
#[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");
}
#[cfg(feature = "high-level-url")]
#[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");
}
#[cfg(feature = "high-level-url")]
#[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");
}
#[cfg(feature = "high-level-url")]
#[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());
}
#[cfg(feature = "high-level-url")]
#[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");
}
#[cfg(feature = "high-level-url")]
#[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");
}
#[cfg(feature = "high-level-url")]
#[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");
}
#[cfg(feature = "high-level-url")]
#[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");
}
#[cfg(feature = "high-level-url")]
#[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")]
#[cfg(feature = "high-level-url")]
#[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")]
#[cfg(feature = "high-level-url")]
#[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")]
#[cfg(feature = "high-level-url")]
#[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");
}
#[cfg(feature = "advanced-routing")]
#[cfg(feature = "high-level-url")]
#[test]
fn resolved_route_key_matrix() {
use crate::transport_hints::ResolvedTarget;
let origin = url::Url::parse("http://origin.example/").unwrap();
let target: ResolvedTarget =
ResolvedTarget::new(["127.0.0.1:80".parse::<SocketAddr>().unwrap()]).unwrap();
let base = ResolvedRouteKey::new(&origin, &target, None);
let same = ResolvedRouteKey::new(&origin, &target, None);
assert!(
base == same,
"same origin + same ordered addresses + same SNI must reuse"
);
let with_path = url::Url::parse("http://origin.example/a?b=1#f").unwrap();
let other_path = url::Url::parse("http://origin.example/other").unwrap();
assert!(
ResolvedRouteKey::new(&with_path, &target, None)
== ResolvedRouteKey::new(&other_path, &target, None),
"path/query/fragment must not fragment resolved identity"
);
let explicit_default = url::Url::parse("http://origin.example:80/").unwrap();
assert!(
ResolvedRouteKey::new(&origin, &target, None)
== ResolvedRouteKey::new(&explicit_default, &target, None),
"explicit default port must reuse"
);
let https = url::Url::parse("https://origin.example/").unwrap();
let https_target: ResolvedTarget =
ResolvedTarget::new(["127.0.0.1:443".parse::<SocketAddr>().unwrap()]).unwrap();
assert!(
base != ResolvedRouteKey::new(&https, &https_target, None),
"scheme change must fragment resolved identity"
);
let other_host = url::Url::parse("http://other.example/").unwrap();
assert!(
base != ResolvedRouteKey::new(&other_host, &target, None),
"host change must fragment resolved identity"
);
let other_port = url::Url::parse("http://origin.example:8080/").unwrap();
let other_port_target: ResolvedTarget =
ResolvedTarget::new(["127.0.0.1:8080".parse::<SocketAddr>().unwrap()]).unwrap();
assert!(
base != ResolvedRouteKey::new(&other_port, &other_port_target, None),
"effective port change must fragment resolved identity"
);
let other_addr: ResolvedTarget =
ResolvedTarget::new(["127.0.0.2:80".parse::<SocketAddr>().unwrap()]).unwrap();
assert!(
base != ResolvedRouteKey::new(&origin, &other_addr, None),
"address change must fragment resolved identity"
);
let ordered: ResolvedTarget = ResolvedTarget::new([
"127.0.0.1:80".parse::<SocketAddr>().unwrap(),
"127.0.0.2:80".parse::<SocketAddr>().unwrap(),
])
.unwrap();
let reordered: ResolvedTarget = ResolvedTarget::new([
"127.0.0.2:80".parse::<SocketAddr>().unwrap(),
"127.0.0.1:80".parse::<SocketAddr>().unwrap(),
])
.unwrap();
assert!(
ResolvedRouteKey::new(&origin, &ordered, None)
!= ResolvedRouteKey::new(&origin, &reordered, None),
"address reorder must fragment resolved identity"
);
assert!(
base != ResolvedRouteKey::new(&origin, &target, Some("sni.example")),
"adding an SNI override must fragment resolved identity"
);
assert!(
ResolvedRouteKey::new(&origin, &target, Some("a.example"))
!= ResolvedRouteKey::new(&origin, &target, Some("b.example")),
"SNI override change must fragment resolved identity"
);
assert!(
ResolvedRouteKey::new(&origin, &target, Some("a.example"))
== ResolvedRouteKey::new(&origin, &target, Some("a.example")),
"same SNI override must reuse"
);
}
#[cfg(feature = "advanced-routing")]
#[test]
fn resolved_route_key_from_native_origin() {
use crate::http_origin::HttpOrigin;
use crate::transport_hints::ResolvedTarget;
let uri: http::Uri = "http://origin.example/".parse().expect("valid URI");
let origin = HttpOrigin::from_uri(&uri).expect("native origin parses");
let target = ResolvedTarget::new(["127.0.0.1:80".parse::<SocketAddr>().unwrap()]).unwrap();
let base = ResolvedRouteKey::from_origin(&origin, &target, None);
let same = ResolvedRouteKey::from_origin(&origin, &target, None);
assert!(
base == same,
"same native origin + addresses + SNI must reuse"
);
let explicit: http::Uri = "http://origin.example:80/a?b=1".parse().expect("valid URI");
let explicit_origin = HttpOrigin::from_uri(&explicit).expect("origin parses");
assert!(
base == ResolvedRouteKey::from_origin(&explicit_origin, &target, None),
"explicit default port must reuse"
);
let https: http::Uri = "https://origin.example/".parse().expect("valid URI");
let https_origin = HttpOrigin::from_uri(&https).expect("origin parses");
let https_target =
ResolvedTarget::new(["127.0.0.1:443".parse::<SocketAddr>().unwrap()]).unwrap();
assert!(
base != ResolvedRouteKey::from_origin(&https_origin, &https_target, None),
"scheme change must fragment resolved identity"
);
assert!(
base != ResolvedRouteKey::from_origin(&origin, &target, Some("sni.example")),
"SNI override must fragment resolved identity"
);
}
#[cfg(any(feature = "transport-http1", feature = "transport-http2"))]
#[cfg(feature = "high-level-url")]
#[test]
fn resolved_route_cache_is_bounded() {
use crate::transport::hyper_client::{
BoundedClientCache, RESOLVED_CLIENT_CACHE_MAX_ENTRIES,
};
use crate::transport_hints::ResolvedTarget;
assert_eq!(
RESOLVED_CLIENT_CACHE_MAX_ENTRIES, 64,
"resolved-route cache uses the conservative 64-entry bound"
);
let mut cache: BoundedClientCache<ResolvedRouteKey, usize> =
BoundedClientCache::new(RESOLVED_CLIENT_CACHE_MAX_ENTRIES);
for index in 0..(RESOLVED_CLIENT_CACHE_MAX_ENTRIES + 16) {
let origin =
url::Url::parse(&format!("http://host-{index}.example/")).expect("valid URL");
let target =
ResolvedTarget::new(["127.0.0.1:80".parse::<SocketAddr>().expect("valid addr")])
.expect("non-empty");
cache.insert(ResolvedRouteKey::new(&origin, &target, None), index);
assert!(
cache.len() <= RESOLVED_CLIENT_CACHE_MAX_ENTRIES,
"insertion beyond capacity must not grow the cache"
);
}
assert_eq!(cache.len(), RESOLVED_CLIENT_CACHE_MAX_ENTRIES);
}
}