#[cfg(feature = "advanced-routing")]
use std::sync::Arc;
#[cfg(all(
feature = "proxy",
any(feature = "transport-http1", feature = "transport-http2")
))]
use std::time::Duration;
#[cfg(feature = "tls-rustls")]
use super::configure_tls_alpn;
#[cfg(any(feature = "advanced-routing", feature = "proxy"))]
use super::{ClientConfig, Error, Pool};
use super::{ClientInner, Result};
#[cfg(any(
feature = "transport-http1",
feature = "transport-http2",
feature = "advanced-routing",
feature = "proxy"
))]
use crate::transport::hyper_client::{build_hyper_client, HyperClientPolicy};
#[cfg(any(
feature = "transport-http1",
feature = "transport-http2",
feature = "advanced-routing"
))]
use crate::transport::lifecycle::LifecycleConfig;
#[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,
reason = "the high-level adapter is retained as the test-util entry point for the canonical origin form; the current tree has no caller for it, so the allow keeps the retained constructor warning-free"
)]
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),
},
}
}
}
#[cfg(feature = "advanced-routing")]
#[derive(Debug, Clone, Copy)]
enum DirectRouteBinding<'a> {
Resolved {
target: &'a crate::transport_hints::ResolvedTarget,
sni_hostname: Option<&'a str>,
},
Sni {
sni_hostname: &'a str,
},
}
#[cfg(feature = "advanced-routing")]
fn build_direct_client(
config: &ClientConfig,
direct_connector_config: Option<&crate::transport::direct_connector::DirectConnectorConfig>,
transport_metrics: &Arc<crate::transport::metrics::TransportMetrics>,
pool: &Pool,
lifecycle: &Arc<LifecycleConfig>,
binding: DirectRouteBinding<'_>,
) -> Result<crate::transport::TimeoutDirectClient> {
let connect_timeout = config.timeout.as_ref().and_then(|t| t.connect);
let enabler =
crate::http_version::HttpVersionPolicyEnabler::from_policy(config.http_version_policy);
#[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, enabler);
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(),
);
let sni_hostname = match binding {
DirectRouteBinding::Resolved {
target,
sni_hostname,
} => {
connector = connector.with_resolved_target(target);
sni_hostname
}
DirectRouteBinding::Sni { sni_hostname } => Some(sni_hostname),
};
if let Some(sni_hostname) = sni_hostname {
connector = connector.with_sni(sni_hostname.to_owned());
}
let policy = HyperClientPolicy::new(
config.retry_canceled_requests,
pool.idle_timeout(),
pool.max_idle_per_host(),
enabler,
);
Ok(build_hyper_client(
connector,
&policy,
connect_timeout,
lifecycle,
))
}
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 = build_direct_client(
&self.config,
self.direct_connector_config.as_ref(),
&self.transport_metrics,
&self.pool,
&self.lifecycle,
DirectRouteBinding::Resolved {
target,
sni_hostname,
},
)?;
clients.insert(key, client.clone());
Ok(client)
}
#[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 client = build_direct_client(
&self.config,
self.direct_connector_config.as_ref(),
&self.transport_metrics,
&self.pool,
&self.lifecycle,
DirectRouteBinding::Sni { sni_hostname },
)?;
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 = super::connectors::build_custom_connector(
tls_config,
dialer,
crate::http_version::HttpVersionPolicyEnabler::from_policy(
self.config.http_version_policy,
),
Some(sni_hostname),
)?;
let policy = HyperClientPolicy::new(
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::new(
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::new(
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)
}
}