Struct trillium_proxy::Client

pub struct Client<C>where
    C: Connector,{ /* private fields */ }

A client contains a Config and an optional connection pool and builds conns.

Implementations

impl<C> Client<C>where
    C: Connector,

pub fn new() -> Client<C>

Constructs a new Client without a connection pool and with default configuration.

pub fn with_default_pool(self) -> Client<C>

chainable constructor to enable connection pooling. this can be combined with Client::with_config

use trillium_smol::TcpConnector;
use trillium_client::Client;

let client = Client::<TcpConnector>::new()
    .with_default_pool(); //<-

pub fn with_config(self, config: <C as Connector>::Config) -> Client<C>

chainable constructor to specify Connector configuration. this can be combined with Client::with_default_pool

use trillium_smol::{TcpConnector, ClientConfig};
use trillium_client::Client;

let client = Client::<TcpConnector>::new()
    .with_config(ClientConfig { //<-
        nodelay: Some(true),
        ..Default::default()
    });

pub fn build_conn<M, U>(&self, method: M, url: U) -> Conn<'_, C>where
    M: TryInto<Method>,
    <M as TryInto<Method>>::Error: Debug,
    U: TryInto<Url>,
    <U as TryInto<Url>>::Error: Debug,

builds a new conn borrowing the config on this client. if the client has pooling enabled and there is an available connection to the dns-resolved socket (ip and port), the new conn will reuse that when it is sent.

use trillium_smol::{TcpConnector, ClientConfig};
use trillium_client::Client;
use trillium_testing::prelude::*;
let client = Client::<TcpConnector>::new();

let conn = client.build_conn("get", "http://trillium.rs"); //<-

assert_eq!(conn.method(), Method::Get);
assert_eq!(conn.url().host_str().unwrap(), "trillium.rs");

pub fn get<U>(&self, url: U) -> Conn<'_, C>where
    <U as TryInto<Url>>::Error: Debug,
    U: TryInto<Url>,

Builds a new client conn with the get http method and the provided url.

let client = Client::<TcpConnector>::new();
let conn = client.get("http://localhost:8080/some/route"); //<-

assert_eq!(conn.method(), Method::Get);
assert_eq!(conn.url().to_string(), "http://localhost:8080/some/route");

pub fn post<U>(&self, url: U) -> Conn<'_, C>where
    <U as TryInto<Url>>::Error: Debug,
    U: TryInto<Url>,

Builds a new client conn with the post http method and the provided url.

let client = Client::<TcpConnector>::new();
let conn = client.post("http://localhost:8080/some/route"); //<-

assert_eq!(conn.method(), Method::Post);
assert_eq!(conn.url().to_string(), "http://localhost:8080/some/route");

pub fn put<U>(&self, url: U) -> Conn<'_, C>where
    <U as TryInto<Url>>::Error: Debug,
    U: TryInto<Url>,

Builds a new client conn with the put http method and the provided url.

let client = Client::<TcpConnector>::new();
let conn = client.put("http://localhost:8080/some/route"); //<-

assert_eq!(conn.method(), Method::Put);
assert_eq!(conn.url().to_string(), "http://localhost:8080/some/route");

pub fn delete<U>(&self, url: U) -> Conn<'_, C>where
    <U as TryInto<Url>>::Error: Debug,
    U: TryInto<Url>,

Builds a new client conn with the delete http method and the provided url.

let client = Client::<TcpConnector>::new();
let conn = client.delete("http://localhost:8080/some/route"); //<-

assert_eq!(conn.method(), Method::Delete);
assert_eq!(conn.url().to_string(), "http://localhost:8080/some/route");

pub fn patch<U>(&self, url: U) -> Conn<'_, C>where
    <U as TryInto<Url>>::Error: Debug,
    U: TryInto<Url>,

Builds a new client conn with the patch http method and the provided url.

let client = Client::<TcpConnector>::new();
let conn = client.patch("http://localhost:8080/some/route"); //<-

assert_eq!(conn.method(), Method::Patch);
assert_eq!(conn.url().to_string(), "http://localhost:8080/some/route");

Trait Implementations

impl<C> Clone for Client<C>where
    C: Connector,

fn clone(&self) -> Client<C>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Transport> Debug for Client<Transport>where
    Transport: Connector,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<C> Default for Client<C>where
    C: Connector,

fn default() -> Client<C>

Returns the “default value” for a type.