Struct linera_rpc::grpc::transport::Channel

pub struct Channel { /* private fields */ }

A default batteries included transport channel.

This provides a fully featured http2 gRPC client based on hyper 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.

Implementations

impl Channel

pub fn builder(uri: Uri) -> Endpoint

Create an Endpoint builder that can create Channels.

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

Create an Endpoint from a static string.

Channel::from_static("https://example.com");

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

Create an Endpoint from shared bytes.

Channel::from_shared("https://example.com");

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

Balance a list of Endpoint’s.

This creates a Channel that will load balance across all the provided endpoints.

pub fn balance_channel<K>( capacity: usize, ) -> (Channel, Sender<Change<K, Endpoint>>)

where K: Hash + Eq + Send + Clone + 'static,

Balance a list of Endpoint’s.

This creates a Channel that will listen to a stream of change events and will add or remove provided endpoints.

pub fn balance_channel_with_executor<K, E>( capacity: usize, executor: E, ) -> (Channel, Sender<Change<K, Endpoint>>)

where K: Hash + Eq + Send + Clone + 'static, E: Executor<Pin<Box<dyn Future<Output = ()> + Send>>> + Send + Sync + 'static,

Balance a list of Endpoint’s.

This creates a Channel that will listen to a stream of change events and will add or remove provided endpoints.

The Channel will use the given executor to spawn async tasks.

Trait Implementations

impl Clone for Channel

fn clone(&self) -> Channel

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Channel

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

Formats the value using the given formatter.

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

type Response = Response<UnsyncBoxBody<Bytes, Status>>

Responses given by the service.

type Error = Error

Errors produced by the service.

type Future = ResponseFuture

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_>, ) -> Poll<Result<(), <Channel as Service<Request<UnsyncBoxBody<Bytes, Status>>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call( &mut self, request: Request<UnsyncBoxBody<Bytes, Status>>, ) -> <Channel as Service<Request<UnsyncBoxBody<Bytes, Status>>>>::Future

Process the request and return the response asynchronously.