Struct tonic::client::Grpc

pub struct Grpc<T> { /* private fields */ }

A gRPC client dispatcher.

This will wrap some inner GrpcService and will encode/decode messages via the provided codec.

Each request method takes a Request, a PathAndQuery, and a Codec. The request contains the message to send via the Codec::encoder. The path determines the fully qualified path that will be append to the outgoing uri. The path must follow the conventions explained in the gRPC protocol definition under Path →. An example of this path could look like /greeter.Greeter/SayHello.

Implementations

impl<T> Grpc<T>

pub fn new(inner: T) -> Self

Creates a new gRPC client with the provided GrpcService.

pub fn with_origin(inner: T, origin: Uri) -> Self

Creates a new gRPC client with the provided GrpcService and Uri.

The provided Uri will use only the scheme and authority parts as the path_and_query portion will be set for each method.

pub fn send_compressed(self, encoding: CompressionEncoding) -> Self

Compress requests with the provided encoding.

Requires the server to accept the specified encoding, otherwise it might return an error.

Example

The most common way of using this is through a client generated by tonic-build:

use tonic::transport::Channel;

let channel = Channel::builder("127.0.0.1:3000".parse().unwrap())
    .connect()
    .await
    .unwrap();

let client = TestClient::new(channel).send_compressed(CompressionEncoding::Gzip);

pub fn accept_compressed(self, encoding: CompressionEncoding) -> Self

Enable accepting compressed responses.

Requires the server to also support sending compressed responses.

Example

The most common way of using this is through a client generated by tonic-build:

use tonic::transport::Channel;

let channel = Channel::builder("127.0.0.1:3000".parse().unwrap())
    .connect()
    .await
    .unwrap();

let client = TestClient::new(channel).accept_compressed(CompressionEncoding::Gzip);

pub fn max_decoding_message_size(self, limit: usize) -> Self

Limits the maximum size of a decoded message.

Example

The most common way of using this is through a client generated by tonic-build:

use tonic::transport::Channel;

let channel = Channel::builder("127.0.0.1:3000".parse().unwrap())
    .connect()
    .await
    .unwrap();

// Set the limit to 2MB, Defaults to 4MB.
let limit = 2 * 1024 * 1024;
let client = TestClient::new(channel).max_decoding_message_size(limit);

pub fn max_encoding_message_size(self, limit: usize) -> Self

Limits the maximum size of an ecoded message.

Example

The most common way of using this is through a client generated by tonic-build:

use tonic::transport::Channel;

let channel = Channel::builder("127.0.0.1:3000".parse().unwrap())
    .connect()
    .await
    .unwrap();

// Set the limit to 2MB, Defaults to 4MB.
let limit = 2 * 1024 * 1024;
let client = TestClient::new(channel).max_encoding_message_size(limit);

pub async fn ready(&mut self) -> Result<(), T::Error>

where T: GrpcService<BoxBody>,

Check if the inner GrpcService is able to accept a new request.

This will call GrpcService::poll_ready until it returns ready or an error. If this returns ready the inner GrpcService is ready to accept one more request.

pub async fn unary<M1, M2, C>( &mut self, request: Request<M1>, path: PathAndQuery, codec: C ) -> Result<Response<M2>, Status>

where T: GrpcService<BoxBody>, T::ResponseBody: Body + Send + 'static, <T::ResponseBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>, C: Codec<Encode = M1, Decode = M2>, M1: Send + Sync + 'static, M2: Send + Sync + 'static,

Send a single unary gRPC request.

pub async fn client_streaming<S, M1, M2, C>( &mut self, request: Request<S>, path: PathAndQuery, codec: C ) -> Result<Response<M2>, Status>

where T: GrpcService<BoxBody>, T::ResponseBody: Body + Send + 'static, <T::ResponseBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>, S: Stream<Item = M1> + Send + 'static, C: Codec<Encode = M1, Decode = M2>, M1: Send + Sync + 'static, M2: Send + Sync + 'static,

Send a client side streaming gRPC request.

pub async fn server_streaming<M1, M2, C>( &mut self, request: Request<M1>, path: PathAndQuery, codec: C ) -> Result<Response<Streaming<M2>>, Status>

where T: GrpcService<BoxBody>, T::ResponseBody: Body + Send + 'static, <T::ResponseBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>, C: Codec<Encode = M1, Decode = M2>, M1: Send + Sync + 'static, M2: Send + Sync + 'static,

Send a server side streaming gRPC request.

pub async fn streaming<S, M1, M2, C>( &mut self, request: Request<S>, path: PathAndQuery, codec: C ) -> Result<Response<Streaming<M2>>, Status>

where T: GrpcService<BoxBody>, T::ResponseBody: Body + Send + 'static, <T::ResponseBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>, S: Stream<Item = M1> + Send + 'static, C: Codec<Encode = M1, Decode = M2>, M1: Send + Sync + 'static, M2: Send + Sync + 'static,

Send a bi-directional streaming gRPC request.

Trait Implementations

impl<T: Clone> Clone for Grpc<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Grpc<T>

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

Formats the value using the given formatter.