use std::{fmt, net::SocketAddr, time::Duration};
use crate::{
Body, Limits, Request, Result, Timeouts,
proxy::Policy as ProxyPolicy,
runtime::{Deadline, Executor, Runtime},
tls::{TlsBuilder, Version as TlsVersion},
transport::Transport,
};
use super::{Pool, Settings};
#[derive(Clone)]
pub struct Client {
pool: Pool,
total_timeout: Option<Duration>,
}
#[derive(Default)]
pub struct ClientBuilder {
runtime: Runtime,
proxy: ProxyPolicy,
tls: TlsBuilder,
settings: Settings,
limits: Limits,
timeouts: Timeouts,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct Info {
remote_addr: SocketAddr,
}
impl Info {
#[must_use]
pub const fn remote_addr(self) -> SocketAddr {
self.remote_addr
}
}
impl Client {
pub fn new() -> Result<Self> {
Self::builder().build()
}
#[must_use]
pub fn builder() -> ClientBuilder {
ClientBuilder::default()
}
pub async fn send(&self, request: Request) -> Result<http::Response<Body>> {
crate::client::validate_framing(request.headers(), request.body())?;
let received = self
.send_with_deadline(request, Deadline::after(self.total_timeout, self.timer())?)
.await?;
let mut response = http::Response::from_parts(received.parts, received.body);
response.extensions_mut().insert(Info {
remote_addr: received.remote_addr,
});
Ok(response)
}
pub(crate) fn from_parts(
transport: Transport,
runtime: Runtime,
settings: Settings,
limits: Limits,
timeouts: Timeouts,
) -> Self {
let pool = Pool::new(
transport,
runtime,
settings,
limits,
timeouts.connect_timeout(),
timeouts.idle_connection_timeout(),
timeouts.read_timeout(),
);
Self {
pool,
total_timeout: timeouts.total_timeout(),
}
}
pub(crate) async fn send_with_deadline(
&self,
request: Request,
deadline: Deadline,
) -> Result<super::pool::Received> {
self.pool.send(request, deadline).await
}
pub(crate) fn timer(&self) -> crate::runtime::Timer {
self.pool.timer()
}
}
impl ClientBuilder {
#[must_use]
pub fn runtime(mut self, runtime: Runtime) -> Self {
self.runtime = runtime;
self
}
#[must_use]
pub fn executor(mut self, executor: Executor) -> Self {
self.runtime.set_executor(executor);
self
}
#[must_use]
pub fn resolver(mut self, resolver: impl crate::dns::Resolver + 'static) -> Self {
self.runtime.set_resolver(resolver);
self
}
#[must_use]
pub const fn settings(mut self, settings: Settings) -> Self {
self.settings = settings;
self
}
#[must_use]
pub const fn limits(mut self, limits: Limits) -> Self {
self.limits = limits;
self
}
#[must_use]
pub const fn timeouts(mut self, timeouts: Timeouts) -> Self {
self.timeouts = timeouts;
self
}
#[must_use]
pub fn proxy(mut self, proxy: ProxyPolicy) -> Self {
self.proxy = proxy;
self
}
#[must_use]
pub fn trust_pem(mut self, bundle: impl AsRef<[u8]>) -> Self {
self.tls.roots(bundle.as_ref());
self
}
#[must_use]
pub fn add_root_pem(mut self, bundle: impl AsRef<[u8]>) -> Self {
self.tls.add_roots(bundle.as_ref());
self
}
#[must_use]
pub fn identity_pem(mut self, identity: impl AsRef<[u8]>) -> Self {
self.tls.identity(identity.as_ref());
self
}
#[must_use]
pub fn minimum_tls_version(mut self, version: TlsVersion) -> Self {
self.tls.minimum_version(version);
self
}
#[must_use]
pub fn maximum_tls_version(mut self, version: TlsVersion) -> Self {
self.tls.maximum_version(version);
self
}
pub fn build(self) -> Result<Client> {
self.limits.validate()?;
self.timeouts.validate()?;
self.settings.validate()?;
self.runtime.executor().prepare()?;
let transport = Transport::new(self.tls, self.proxy, self.runtime.clone(), self.settings)?;
Ok(Client::from_parts(
transport,
self.runtime,
self.settings,
self.limits,
self.timeouts,
))
}
}
impl fmt::Debug for Client {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("connection::Client")
.finish_non_exhaustive()
}
}
impl fmt::Debug for ClientBuilder {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("connection::ClientBuilder")
.field("runtime", &self.runtime)
.field("proxy", &self.proxy)
.field("settings", &self.settings)
.field("limits", &self.limits)
.field("timeouts", &self.timeouts)
.finish_non_exhaustive()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn low_level_builder_rejects_invalid_resource_policy() {
let error = Client::builder()
.limits(Limits::default().connections_per_origin(0))
.build()
.unwrap_err();
assert!(error.is_request());
}
}