Struct Client

Source

pub struct Client { /* private fields */ }

Expand description

A default batteries included transport client.

This provides a fully featured http client based on hyper::Client and tower services.

§Multiplexing requests

Sending a request on a client requires a &mut self and thus can only send one request in flight. This is intentional and is required to follow the Service contract from the tower library which this client implementation is built on top of.

tower itself has a concept of poll_ready which is the main mechanism to apply back pressure. poll_ready takes a &mut self and when it returns Poll::Ready we know the Service is able to accept only one request before we must poll_ready again. Due to this fact any async fn that wants to poll for readiness and submit the request must have a &mut self reference.

To work around this and to ease the use of the client, Channel provides a Clone implementation that is cheap. This is because at the very top level the client is backed by a tower_buffer::Buffer which runs the connection in a background task and provides a mpsc client interface. Due to this cloning the Channel type is cheap and encouraged.

Struct Client Copy item path

§Multiplexing requests

Implementations§

impl Client

pub fn builder(uri: Uri) -> ApiNode

pub fn from_static(s: &'static str) -> ApiNode

pub fn from_shared(s: impl Into<Bytes>) -> Result<ApiNode, InvalidUri>

impl Client

pub fn account_api(&self) -> Box<AccountRoutes>

pub fn chain_api(&self) -> Box<ChainRoutes>

pub fn node_api(&self) -> Box<NodeRoutes>

pub fn network_api(&self) -> Box<NetworkRoutes>

pub fn mosaic_api(&self) -> Box<MosaicRoutes>

pub fn namespace_api(&self) -> Box<NamespaceRoutes>

pub fn transaction_api(&self) -> Box<TransactionRoutes>

pub fn resolver_api(&self) -> Box<ResolverRoutes>

pub fn metadata_v2_api(&self) -> Box<MetadataV2Routes>

Trait Implementations§

impl Clone for Client

fn clone(&self) -> Client

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

impl Debug for Client

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

impl Service<Request<ReplayBody>> for Client

type Response = Response<Body>

type Error = Error

type Future = Pin<Box<dyn Future<Output = Result<<Client as Service<Request<ReplayBody>>>::Response, <Client as Service<Request<ReplayBody>>>::Error>> + Send>>

fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

fn call(&mut self, request: Request<ReplayBody>) -> Self::Future

Auto Trait Implementations§

impl !Freeze for Client

impl !RefUnwindSafe for Client

impl Send for Client

impl Sync for Client

impl Unpin for Client

impl !UnwindSafe for Client

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> CloneToUninit for Twhere T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)

impl<T> From<T> for T

fn from(t: T) -> T

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

fn in_current_span(self) -> Instrumented<Self>

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<T> Same for T

type Output = T

impl<T, Request> ServiceExt<Request> for Twhere T: Service<Request> + ?Sized,

fn ready(&mut self) -> Ready<'_, Self, Request>where Self: Sized,

fn ready_and(&mut self) -> Ready<'_, Self, Request>where Self: Sized,

fn ready_oneshot(self) -> ReadyOneshot<Self, Request>where Self: Sized,

fn oneshot(self, req: Request) -> Oneshot<Self, Request>where Self: Sized,

fn call_all<S>(self, reqs: S) -> CallAll<Self, S>where Self: Sized, Self::Error: Into<Box<dyn Error + Sync + Send>>, S: Stream<Item = Request>,

fn and_then<F>(self, f: F) -> AndThen<Self, F>where Self: Sized, F: Clone,

fn map_response<F, Response>(self, f: F) -> MapResponse<Self, F>where Self: Sized, F: FnOnce(Self::Response) -> Response + Clone,

fn map_err<F, Error>(self, f: F) -> MapErr<Self, F>where Self: Sized, F: FnOnce(Self::Error) -> Error + Clone,

fn map_result<F, Response, Error>(self, f: F) -> MapResult<Self, F>where Self: Sized, Error: From<Self::Error>, F: FnOnce(Result<Self::Response, Self::Error>) -> Result<Response, Error> + Clone,

fn map_request<F, NewRequest>(self, f: F) -> MapRequest<Self, F>where Self: Sized, F: FnMut(NewRequest) -> Request,

fn then<F, Response, Error, Fut>(self, f: F) -> Then<Self, F>where Self: Sized, Error: From<Self::Error>, F: FnOnce(Result<Self::Response, Self::Error>) -> Fut + Clone, Fut: Future<Output = Result<Response, Error>>,

fn map_future<F, Fut, Response, Error>(self, f: F) -> MapFuture<Self, F>where Self: Sized, F: FnMut(Self::Future) -> Fut, Error: From<Self::Error>, Fut: Future<Output = Result<Response, Error>>,

fn boxed(self) -> BoxService<Request, Self::Response, Self::Error>where Self: Sized + Send + 'static, Self::Future: Send + 'static,

fn boxed_clone(self) -> BoxCloneService<Request, Self::Response, Self::Error>where Self: Sized + Clone + Send + 'static, Self::Future: Send + 'static,

impl<T> ToOwned for Twhere T: Clone,

type Owned = T

fn to_owned(&self) -> T

fn clone_into(&self, target: &mut T)

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

impl<V, T> VZip<V> for Twhere V: MultiLane<T>,

Struct Client

impl<T> Any for T
where T: 'static + ?Sized,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<T> CloneToUninit for T
where T: Clone,

impl<T, U> Into<U> for T
where U: From<T>,

impl<T, Request> ServiceExt<Request> for T
where T: Service<Request> + ?Sized,

fn ready(&mut self) -> Ready<'_, Self, Request>
where Self: Sized,

fn ready_and(&mut self) -> Ready<'_, Self, Request>
where Self: Sized,

fn ready_oneshot(self) -> ReadyOneshot<Self, Request>
where Self: Sized,

fn oneshot(self, req: Request) -> Oneshot<Self, Request>
where Self: Sized,

fn call_all<S>(self, reqs: S) -> CallAll<Self, S>
where Self: Sized, Self::Error: Into<Box<dyn Error + Sync + Send>>, S: Stream<Item = Request>,

fn and_then<F>(self, f: F) -> AndThen<Self, F>
where Self: Sized, F: Clone,

fn map_response<F, Response>(self, f: F) -> MapResponse<Self, F>
where Self: Sized, F: FnOnce(Self::Response) -> Response + Clone,

fn map_err<F, Error>(self, f: F) -> MapErr<Self, F>
where Self: Sized, F: FnOnce(Self::Error) -> Error + Clone,

fn map_result<F, Response, Error>(self, f: F) -> MapResult<Self, F>
where Self: Sized, Error: From<Self::Error>, F: FnOnce(Result<Self::Response, Self::Error>) -> Result<Response, Error> + Clone,

fn map_request<F, NewRequest>(self, f: F) -> MapRequest<Self, F>
where Self: Sized, F: FnMut(NewRequest) -> Request,

fn then<F, Response, Error, Fut>(self, f: F) -> Then<Self, F>
where Self: Sized, Error: From<Self::Error>, F: FnOnce(Result<Self::Response, Self::Error>) -> Fut + Clone, Fut: Future<Output = Result<Response, Error>>,

fn map_future<F, Fut, Response, Error>(self, f: F) -> MapFuture<Self, F>
where Self: Sized, F: FnMut(Self::Future) -> Fut, Error: From<Self::Error>, Fut: Future<Output = Result<Response, Error>>,

fn boxed(self) -> BoxService<Request, Self::Response, Self::Error>
where Self: Sized + Send + 'static, Self::Future: Send + 'static,

fn boxed_clone(self) -> BoxCloneService<Request, Self::Response, Self::Error>
where Self: Sized + Clone + Send + 'static, Self::Future: Send + 'static,

impl<T> ToOwned for T
where T: Clone,

impl<T, U> TryFrom<U> for T
where U: Into<T>,

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,