Struct tonic::transport::Channel[−][src]

pub struct Channel { /* fields omitted */ }

Expand description

A default batteries included transport channel.

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

Multiplexing requests

Sending a request on a channel 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 channel 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 channel, Channel provides a Clone implementation that is cheap. This is because at the very top level the channel is backed by a tower_buffer::Buffer which runs the connection in a background task and provides a mpsc channel interface. Due to this cloning the Channel type is cheap and encouraged.

Struct tonic::transport::Channel[−][src]

Multiplexing requests

Implementations

impl Channel

pub fn builder(uri: Uri) -> Endpoint

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

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

pub fn balance_list(list: impl Iterator<Item = Endpoint>) -> Self

pub fn balance_channel<K>( capacity: usize) -> (Self, Sender<Change<K, Endpoint>>) where K: Hash + Eq + Send + Clone + 'static,

Trait Implementations

impl Clone for Channel

fn clone(&self) -> Channel

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

impl Debug for Channel

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

impl Service<Request<BoxBody<Bytes, Status>>> for Channel

type Response = Response<Body>

type Error = Error

type Future = ResponseFuture

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

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

Auto Trait Implementations

impl !RefUnwindSafe for Channel

impl Send for Channel

impl Sync for Channel

impl Unpin for Channel

impl !UnwindSafe for Channel

Blanket Implementations

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

pub fn type_id(&self) -> TypeId

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

pub fn borrow(&self) -> &T

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

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

impl<T> From<T> for T

pub 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 T where U: From<T>,

pub fn into(self) -> U

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

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

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

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

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

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

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

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

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

fn map_result<F, Response, Error>(self, f: F) -> MapResult<Self, F> where 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 F: FnMut(NewRequest) -> Request + Clone,

fn then<F, Response, Error, Fut>(self, f: F) -> Then<Self, F> where 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 F: FnMut(Self::Future) -> Fut, Error: From<Self::Error>, Fut: Future<Output = Result<Response, Error>>,

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

type Owned = T

pub fn to_owned(&self) -> T

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

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

type Error = Infallible

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

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

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

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

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

pub fn vzip(self) -> V

impl<T> WithSubscriber for T

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

fn with_current_subscriber(self) -> WithDispatch<Self>

pub fn balance_channel<K>(
capacity: usize
) -> (Self, Sender<Change<K, Endpoint>>) where
K: Hash + Eq + Send + Clone + 'static,

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, U> Into<U> for T where
U: From<T>,

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

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

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

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

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

fn map_result<F, Response, Error>(self, f: F) -> MapResult<Self, F> where
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
F: FnMut(NewRequest) -> Request + Clone,

fn then<F, Response, Error, Fut>(self, f: F) -> Then<Self, F> where
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
F: FnMut(Self::Future) -> Fut,
Error: From<Self::Error>,
Fut: Future<Output = Result<Response, Error>>,

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>,