pub struct Client { /* private fields */ }Implementations§
Source§impl Client
impl Client
Sourcepub fn new(config: ClientConfig) -> Self
pub fn new(config: ClientConfig) -> Self
Build a client. Invalid proxy settings do not panic: every request then returns
HttpError::InvalidRequest. Use Client::try_new to see the error up front.
Sourcepub fn try_new(config: ClientConfig) -> Result<Self, HttpError>
pub fn try_new(config: ClientConfig) -> Result<Self, HttpError>
Build a client, failing when the proxy settings are invalid.
Sourcepub fn on_attempt_outcome(
self,
observer: impl Fn(&AttemptOutcome) + Send + Sync + 'static,
) -> Self
pub fn on_attempt_outcome( self, observer: impl Fn(&AttemptOutcome) + Send + Sync + 'static, ) -> Self
Observe every finished transport hop before its response body is read.
Receives sanitized status/error, delivery evidence & the final hop’s retry delay;
see AttemptOutcome. Runs on the calling thread (async: polling task), so it
should not block. Replaces any observer previously attached to this client.
Kept privately on the client so existing ClientConfig literals remain valid.
Sourcepub fn compression(self, on: bool) -> Self
pub fn compression(self, on: bool) -> Self
Ask for compressed responses (default true). false sends Accept-Encoding: identity
on every request that sets no Accept-Encoding of its own, so an SSE or provider stream
is not buffered or re-encoded by an intermediary. Kept on the client, not on
ClientConfig, so existing ClientConfig struct literals keep compiling.
Sourcepub fn verifier_kind(&self) -> &'static str
pub fn verifier_kind(&self) -> &'static str
Which certificate verifier this client was built with: "platform" (the OS verifier)
or "bundled" (Mozilla roots). It follows ClientConfig::trust.
Sourcepub fn proxy_diagnostic(&self) -> Option<&ProxyDiagnostic>
pub fn proxy_diagnostic(&self) -> Option<&ProxyDiagnostic>
The proxy this client uses, if any, without credentials. See ProxyDiagnostic.
None also when ProxyMode::System is decided per request URL, because there is no
single proxy to report.
Sourcepub fn proxy_mode_used(&self) -> &ProxyModeUsed
pub fn proxy_mode_used(&self) -> &ProxyModeUsed
Which proxy source this client actually uses. For ProxyMode::System it says
whether the operating system’s proxy was followed or a fallback was taken, and why.
Sourcepub fn first_party(hosts: Vec<String>) -> Self
pub fn first_party(hosts: Vec<String>) -> Self
Client that may reach only hosts (exact match), only over HTTPS; see
ClientConfig::first_party.
pub fn config(&self) -> &ClientConfig
Sourcepub fn send(&self, req: &Request) -> Result<Response, HttpError>
pub fn send(&self, req: &Request) -> Result<Response, HttpError>
Buffered request; non-2xx becomes HttpError::Status.
Sourcepub fn send_with_flag(
&self,
req: &Request,
flag: &AtomicBool,
) -> Result<Response, HttpError>
pub fn send_with_flag( &self, req: &Request, flag: &AtomicBool, ) -> Result<Response, HttpError>
Client::send cancelled through a borrowed flag, for callers that own an
AtomicBool and cannot hand out an Arc (CancelToken::from_flag). The flag is
checked at the same points as a token: between attempts, during retry sleeps and
before every body read (it still cannot interrupt a socket call already waiting for
headers; response_timeout bounds that). It replaces any Request::cancel token
on this call. Buffered calls only: a stream outlives the borrow, so stream and
stream_any keep taking a CancelToken.
Sourcepub fn send_any_with_flag(
&self,
req: &Request,
flag: &AtomicBool,
) -> Result<Response, HttpError>
pub fn send_any_with_flag( &self, req: &Request, flag: &AtomicBool, ) -> Result<Response, HttpError>
Client::send_any with a borrowed cancel flag; see Client::send_with_flag.
Sourcepub fn send_any(&self, req: &Request) -> Result<Response, HttpError>
pub fn send_any(&self, req: &Request) -> Result<Response, HttpError>
Buffered request returning any final status (retryable statuses are still retried).
Sourcepub fn send_headers(&self, req: &Request) -> Result<ResponseHead, HttpError>
pub fn send_headers(&self, req: &Request) -> Result<ResponseHead, HttpError>
Status and headers only, for any status, without reading the body. Redirects, retries,
the address policy and cancellation behave as for Client::send_any; the body is
dropped unread, which closes that connection. final_url and hops report where
redirects led.
Sourcepub fn stream_any(&self, req: &Request) -> Result<StreamResponse, HttpError>
pub fn stream_any(&self, req: &Request) -> Result<StreamResponse, HttpError>
Streaming request returning any final status with its headers and streaming body
(retryable statuses are still retried per policy). The caller inspects status and
headers (for example 401 plus www-authenticate) and bounds the body. Timeout and
cancellation behave as for Client::stream.
Sourcepub fn stream(&self, req: &Request) -> Result<StreamResponse, HttpError>
pub fn stream(&self, req: &Request) -> Result<StreamResponse, HttpError>
Streaming request; non-2xx becomes HttpError::Status (use Client::stream_any
to receive such a response with its headers). Retries happen
only before the response headers arrive (never mid-stream). Uses
Request::timeout as the total stream budget when set, otherwise
ClientConfig::stream_timeout.