tez 0.0.3

A lightweight, ergonomic, and fast high-level HTTP client for Rust
Documentation
//! Low-level HTTP/1.1 and HTTP/2 connections, pooling, and protocol policy.

use std::net::SocketAddr;

use http::{HeaderValue, Uri};

use crate::{Error, Result, runtime::Io};

mod client;
pub(crate) mod handshake;
mod pool;
mod settings;

pub use client::{Client, ClientBuilder, Info};
pub(crate) use pool::Pool;
pub use settings::{Http1, Http2, Settings};

#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
pub(crate) enum Protocol {
    Http1,
    Http2,
}

#[derive(Clone, Debug, Eq, Hash, PartialEq)]
pub(crate) struct Origin {
    pub(crate) scheme: Scheme,
    pub(crate) host: String,
    pub(crate) port: u16,
}

#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
pub(crate) enum Scheme {
    Http,
    Https,
}

pub(crate) struct Connection {
    pub(crate) io: Io,
    pub(crate) protocol: Protocol,
    pub(crate) remote_addr: SocketAddr,
    pub(crate) absolute_form: bool,
    pub(crate) proxy_authorization: Option<HeaderValue>,
}

impl Origin {
    pub(crate) fn from_uri(uri: &Uri) -> Result<Self> {
        let scheme = match uri.scheme_str() {
            Some("http") => Scheme::Http,
            Some("https") => Scheme::Https,
            _ => return Err(Error::request("request URL must use HTTP or HTTPS")),
        };
        let authority = uri
            .authority()
            .ok_or_else(|| Error::request("request URL must include a host"))?;
        Ok(Self {
            scheme,
            host: authority
                .host()
                .strip_prefix('[')
                .and_then(|host| host.strip_suffix(']'))
                .unwrap_or_else(|| authority.host())
                .to_ascii_lowercase(),
            port: authority.port_u16().unwrap_or(match scheme {
                Scheme::Http => 80,
                Scheme::Https => 443,
            }),
        })
    }

    pub(crate) fn authority(&self) -> String {
        if self.host.contains(':') {
            format!("[{}]:{}", self.host, self.port)
        } else {
            format!("{}:{}", self.host, self.port)
        }
    }

    pub(crate) fn host_header(&self) -> String {
        let default_port = matches!(
            (self.scheme, self.port),
            (Scheme::Http, 80) | (Scheme::Https, 443)
        );
        if default_port {
            if self.host.contains(':') {
                format!("[{}]", self.host)
            } else {
                self.host.clone()
            }
        } else {
            self.authority()
        }
    }

    pub(crate) const fn secure(&self) -> bool {
        matches!(self.scheme, Scheme::Https)
    }
}

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

    #[test]
    fn origins_default_ports_and_format_ipv6_authorities() {
        let https = Origin::from_uri(&"https://example.com/a".parse().unwrap()).unwrap();
        assert_eq!(https.port, 443);
        assert_eq!(https.authority(), "example.com:443");

        let ipv6 = Origin::from_uri(&"http://[::1]:8080/a".parse().unwrap()).unwrap();
        assert_eq!(ipv6.host, "::1");
        assert_eq!(ipv6.authority(), "[::1]:8080");

        let default_ipv6 = Origin::from_uri(&"https://[::1]/a".parse().unwrap()).unwrap();
        assert_eq!(default_ipv6.host_header(), "[::1]");
    }
}