Struct Client 

pub struct Client {
    pub user_agent: &'static str,
    pub timeout: Duration,
    pub response_max: usize,
    pub tcp_buffer: usize,
}

How a board’s requests are made: what it calls itself, and its limits. Start from Client::DEFAULT.

Fields

user_agent: &'static str

The User-Agent sent — the board’s name, so the far end’s logs say who asked.

timeout: Duration

How long a whole exchange may take, DNS through the last byte. Default 30 seconds.

One deadline around all of it rather than one per step, because the caller cares how long it can be kept waiting, not which stage was slow — and the failure it bounds is a server that accepts a connection and then says nothing.

response_max: usize

Bytes of response kept: status line, headers and body. Default 4 KiB.

A response larger than this is cut short. A chunked body cut short fails to parse, and a plain one comes back as a prefix — which is why it is a limit to size against the largest answer expected, generously, rather than a buffer to economize on.

tcp_buffer: usize

TCP buffer, in bytes, per direction. Default 4 KiB.

Implementations

impl Client

pub const DEFAULT: Self

The defaults, as a constant.

pub async fn send( &self, stack: Stack<'_>, config: Arc<ClientConfig>, request: &Request<'_>, ) -> Result<Response, Error>

Performs request and returns what came back, whatever its status.

The TCP and response buffers come off the heap for the length of the exchange.

Trait Implementations

impl Clone for Client

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Client

impl Debug for Client

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

Formats the value using the given formatter.