tez 0.0.0

A lightweight, ergonomic, and fast high-level HTTP client for Rust
Documentation
use std::{
    fmt,
    future::Future,
    pin::Pin,
    sync::{Arc, Mutex},
    task::{Context, Poll},
    time::Duration,
};

use bytes::Bytes;
use http::{
    HeaderMap, HeaderName, HeaderValue, Version,
    header::{TRAILER, TRANSFER_ENCODING},
};
use http_body::Body as _;
use http_body::{Frame, SizeHint};

use crate::{
    Body, BodyChunk, BodyFrame, BodySource, Error, ErrorKind, Proxy, Request, Response, Result, Tls,
};
#[cfg(feature = "rustls")]
use crate::{Certificate, TlsVersion, tls::CertificateEncoding};

pub(crate) type BoxFuture<'a, T> = Pin<Box<dyn Future<Output = T> + Send + 'a>>;

pub(crate) trait Transport: Send + Sync + 'static {
    fn send(&self, request: Request) -> BoxFuture<'_, Result<Response>>;
}

impl<T> Transport for Arc<T>
where
    T: Transport + ?Sized,
{
    fn send(&self, request: Request) -> BoxFuture<'_, Result<Response>> {
        (**self).send(request)
    }
}

#[derive(Clone)]
pub(crate) struct ReqwestTransport {
    client: reqwest::Client,
}

pub(crate) struct ReqwestConfig {
    pub(crate) proxies: Vec<Proxy>,
    pub(crate) connect_timeout: Duration,
    pub(crate) read_timeout: Duration,
    pub(crate) tls: Tls,
}

impl ReqwestTransport {
    pub(crate) fn new(config: ReqwestConfig) -> Result<Self> {
        let mut builder = reqwest::Client::builder()
            .redirect(reqwest::redirect::Policy::none())
            .referer(false)
            .retry(reqwest::retry::never())
            .connect_timeout(config.connect_timeout)
            .read_timeout(config.read_timeout)
            .no_proxy();

        #[cfg(not(feature = "gzip"))]
        {
            builder = builder.no_gzip();
        }
        #[cfg(not(feature = "brotli"))]
        {
            builder = builder.no_brotli();
        }
        #[cfg(not(feature = "deflate"))]
        {
            builder = builder.no_deflate();
        }
        #[cfg(not(feature = "zstd"))]
        {
            builder = builder.no_zstd();
        }
        #[cfg(not(feature = "http2"))]
        {
            builder = builder.http1_only();
        }

        #[cfg(feature = "rustls")]
        {
            let roots = config
                .tls
                .roots
                .iter()
                .map(to_reqwest_certificate)
                .collect::<Result<Vec<_>>>()?;
            builder = builder
                .tls_backend_rustls()
                .tls_certs_merge(roots)
                .https_only(config.tls.https_only)
                .tls_version_min(match config.tls.minimum_version {
                    TlsVersion::Tls12 => reqwest::tls::Version::TLS_1_2,
                    TlsVersion::Tls13 => reqwest::tls::Version::TLS_1_3,
                });
            if let Some(identity) = config.tls.identity {
                let identity = reqwest::Identity::from_pem(identity.pem.as_slice())
                    .map_err(|_| Error::new(ErrorKind::Tls, "invalid PEM client identity"))?;
                builder = builder.identity(identity);
            }
        }

        #[cfg(not(feature = "rustls"))]
        if !config.tls.is_default() {
            return Err(Error::new(
                ErrorKind::Tls,
                "custom TLS configuration requires the rustls feature",
            ));
        }

        for proxy in config.proxies {
            for proxy in proxy.into_reqwest()? {
                builder = builder.proxy(proxy);
            }
        }

        let client = builder.build().map_err(Error::from_reqwest)?;
        Ok(Self { client })
    }
}

#[cfg(feature = "rustls")]
fn to_reqwest_certificate(certificate: &Certificate) -> Result<reqwest::Certificate> {
    match certificate.encoding {
        CertificateEncoding::Pem => reqwest::Certificate::from_pem(&certificate.bytes),
        CertificateEncoding::Der => reqwest::Certificate::from_der(&certificate.bytes),
    }
    .map_err(|_| Error::new(ErrorKind::Tls, "invalid custom TLS root certificate"))
}

impl Transport for ReqwestTransport {
    fn send(&self, request: Request) -> BoxFuture<'_, Result<Response>> {
        Box::pin(async move {
            #[cfg(not(feature = "rustls"))]
            if request.url().scheme() == "https" {
                return Err(Error::new(
                    ErrorKind::Tls,
                    "the default transport requires the rustls feature for HTTPS",
                ));
            }

            let (method, url, mut headers, body, timeout) = request.into_parts();
            let declared_trailers = body.trailer_names();
            if !body.is_absent() && (body.len().is_none() || body.may_have_trailers()) {
                headers.insert(TRANSFER_ENCODING, HeaderValue::from_static("chunked"));
            }
            let mut builder = self.client.request(method, url.clone()).headers(headers);

            if !body.is_absent() {
                builder = builder.body(reqwest::Body::wrap(OutgoingBody {
                    body: Mutex::new(body),
                    declared_trailers,
                }));
            }
            if let Some(timeout) = timeout {
                builder = builder.timeout(timeout);
            }

            let response = builder.send().await.map_err(Error::from_reqwest)?;
            let status = response.status();
            let version = response.version();
            let headers = response.headers().clone();
            let effective_url = response.url().clone();
            let remote_addr = response.remote_addr();
            let trailer_names = declared_trailer_names(&headers);
            let response: http::Response<reqwest::Body> = response.into();
            let (_, body) = response.into_parts();
            let may_have_trailers = !trailer_names.is_empty()
                || matches!(version, Version::HTTP_2 | Version::HTTP_3)
                || body.size_hint().exact().is_none();

            let mut response = Response::builder()
                .status(status)
                .version(version)
                .headers(headers)
                .effective_url(effective_url)
                .body(Body::from_source(IncomingBody {
                    body,
                    may_have_trailers,
                    trailer_names,
                }));
            if let Some(remote_addr) = remote_addr {
                response = response.remote_addr(remote_addr);
            }
            response.build()
        })
    }
}

impl fmt::Debug for ReqwestTransport {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter
            .debug_struct("DefaultTransport")
            .finish_non_exhaustive()
    }
}

struct IncomingBody {
    body: reqwest::Body,
    may_have_trailers: bool,
    trailer_names: Vec<HeaderName>,
}

struct OutgoingBody {
    body: Mutex<Body>,
    declared_trailers: Vec<HeaderName>,
}

impl http_body::Body for OutgoingBody {
    type Data = Bytes;
    type Error = Error;

    fn poll_frame(
        mut self: Pin<&mut Self>,
        context: &mut Context<'_>,
    ) -> Poll<Option<Result<Frame<Self::Data>>>> {
        let body = self
            .body
            .get_mut()
            .unwrap_or_else(std::sync::PoisonError::into_inner);
        match BodySource::poll_frame(Pin::new(body), context) {
            Poll::Ready(Ok(Some(BodyFrame::Data(chunk)))) => {
                Poll::Ready(Some(Ok(Frame::data(chunk.into_shared()))))
            }
            Poll::Ready(Ok(Some(BodyFrame::Trailers(trailers)))) => {
                if self.declared_trailers.is_empty()
                    || trailers
                        .keys()
                        .any(|name| !self.declared_trailers.contains(name))
                    || trailers
                        .keys()
                        .any(|name| trailers.get_all(name).iter().count() > 1)
                {
                    Poll::Ready(Some(Err(Error::new(
                        ErrorKind::BodyIo,
                        "outgoing trailers were undeclared or used repeated field values unsupported by HTTP/1",
                    ))))
                } else {
                    Poll::Ready(Some(Ok(Frame::trailers(trailers))))
                }
            }
            Poll::Ready(Ok(None)) => Poll::Ready(None),
            Poll::Ready(Err(error)) => Poll::Ready(Some(Err(error))),
            Poll::Pending => Poll::Pending,
        }
    }

    fn size_hint(&self) -> SizeHint {
        let mut hint = SizeHint::new();
        let body = self
            .body
            .lock()
            .unwrap_or_else(std::sync::PoisonError::into_inner);
        if !body.may_have_trailers()
            && let Some(length) = body.len()
        {
            hint.set_exact(length);
        }
        hint
    }
}

impl BodySource for IncomingBody {
    fn poll_frame(
        mut self: Pin<&mut Self>,
        context: &mut Context<'_>,
    ) -> Poll<Result<Option<BodyFrame>>> {
        loop {
            let frame = match Pin::new(&mut self.body).poll_frame(context) {
                Poll::Ready(Some(Ok(frame))) => frame,
                Poll::Ready(Some(Err(error))) => {
                    return Poll::Ready(Err(Error::from_reqwest(error)));
                }
                Poll::Ready(None) => return Poll::Ready(Ok(None)),
                Poll::Pending => return Poll::Pending,
            };

            let frame = match frame.into_data() {
                Ok(data) => {
                    return Poll::Ready(Ok(Some(BodyFrame::Data(BodyChunk::from_shared(data)))));
                }
                Err(frame) => frame,
            };
            if let Ok(trailers) = frame.into_trailers() {
                return Poll::Ready(Ok(Some(BodyFrame::Trailers(trailers))));
            }
        }
    }

    fn len(&self) -> Option<u64> {
        self.body.size_hint().exact()
    }

    fn may_have_trailers(&self) -> bool {
        self.may_have_trailers
    }

    fn trailer_names(&self) -> Vec<HeaderName> {
        self.trailer_names.clone()
    }
}

fn declared_trailer_names(headers: &HeaderMap) -> Vec<HeaderName> {
    let mut names = Vec::new();
    for value in headers.get_all(TRAILER) {
        let Ok(value) = value.to_str() else {
            continue;
        };
        for name in value
            .split(',')
            .map(str::trim)
            .filter(|name| !name.is_empty())
        {
            let Ok(name) = HeaderName::from_bytes(name.as_bytes()) else {
                continue;
            };
            if !names.contains(&name) {
                names.push(name);
            }
        }
    }
    names
}

#[cfg(test)]
mod describe_transport {
    use super::*;

    #[test]
    fn it_default_transport_debug_hides_backend_identity() {
        let transport = ReqwestTransport::new(ReqwestConfig {
            proxies: Vec::new(),
            connect_timeout: Duration::from_secs(10),
            read_timeout: Duration::from_secs(30),
            tls: Tls::default(),
        })
        .unwrap();

        assert_eq!(
            format!("{transport:?}").split_whitespace().next(),
            Some("DefaultTransport")
        );
    }

    #[cfg(not(feature = "rustls"))]
    #[tokio::test]
    async fn it_default_transport_rejects_https_without_rustls() {
        let transport = ReqwestTransport::new(ReqwestConfig {
            proxies: Vec::new(),
            connect_timeout: Duration::from_secs(10),
            read_timeout: Duration::from_secs(30),
            tls: Tls::default(),
        })
        .unwrap();
        let request = Request::get("https://example.com").build().unwrap();

        let error = transport.send(request).await.unwrap_err();

        assert_eq!(error.kind(), ErrorKind::Tls);
    }
}