Struct Client 

pub struct Client { /* private fields */ }

Sends the requests of a generated client through a tower service.

Client::default sends with reqwest (feature reqwest) and retries transient failures (feature retry). Client::from_service takes any other service, as is, and Client::layer wraps the current one in a tower layer:

use std::time::Duration;
use timvw_rust_runtime::Client;

let client = Client::default().layer(tower::timeout::TimeoutLayer::new(Duration::from_secs(30)));

Implementations

impl Client

pub fn new() -> Self

Available on crate feature reqwest only.

A client that sends with a new reqwest::Client, retrying with RetryPolicy::default (feature retry).

pub fn from_reqwest(client: Client) -> Self

Available on crate feature reqwest only.

A client that sends with the given reqwest::Client, for example one with a proxy or a custom TLS setup, and retries like Client::new.

For other retries, or none, start from the bare service instead: Client::from_service(ReqwestService::new(client)), then add the layers you want.

pub fn from_service<S, B>(service: S) -> Self

where S: Service<Request<Body>, Response = Response<B>> + Clone + MaybeSend + 'static, S::Error: Into<BoxError>, S::Future: MaybeSend + 'static, B: Body + MaybeSend + MaybeSync + 'static, B::Data: Into<Bytes>, B::Error: Into<BoxError>,

A client that sends with any tower service from http::Request<Body> to http::Response<B>.

The service must be Clone and Send, not Sync: services such as ConcurrencyLimit that cannot be shared between threads are held behind a lock that is only taken to clone them. On WebAssembly (target_family = "wasm") it need not be Send either (MaybeSend), nor its future and body.

pub fn layer<L, B>(self, layer: L) -> Self

where L: Layer<HttpService>, L::Service: Service<Request<Body>, Response = Response<B>> + Clone + MaybeSend + 'static, <L::Service as Service<Request<Body>>>::Error: Into<BoxError>, <L::Service as Service<Request<Body>>>::Future: MaybeSend + 'static, B: Body + MaybeSend + MaybeSync + 'static, B::Data: Into<Bytes>, B::Error: Into<BoxError>,

Wraps the client’s service in a tower layer: retries, timeouts, rate limits, tracing, …

Layers apply from the inside out: the last one added sees a request first.

pub fn service(&self) -> &HttpService

The service requests go through.

pub fn request(&self, method: Method, url: &str) -> RequestBuilder

Starts a request to url.

pub async fn execute(&self, request: Request<Body>) -> Result<Response, Error>

Sends a request.

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 Debug for Client

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

Formats the value using the given formatter.

impl Default for Client

With feature reqwest Client::new: reqwest, with retries when feature retry is on; without it a client whose every request fails, to be replaced with Client::from_service.

fn default() -> Self

Returns the “default value” for a type.