Struct Client 

pub struct Client<'a> { /* private fields */ }

A websocket-tunneled, browser enabled tonic client.

This client can be used in place of tonic’s Channel. It tunnels the request through a websocket connection to the server that reconstructs them and send them to their respective handlers.

Cryptography

This transport implementation does not directly support encryption. It is however possible to encrypt the websocket connection itself. However, client authentication is not possible that way.

Example

Assuming we have the greeter example in scope, we can instanciate a connection like so:

let client = Client::connect("ws://localhost:8080").await.unwrap();
let mut client = greeter_client::GreeterClient::new(client);

let request = tonic::Request::new(HelloRequest {
   name: "WebTonic".into(),
});

let response = client.say_hello(request).await.unwrap().into_inner();
assert_eq!(response.message, "Hello WebTonic!");

Implementations

impl Client<'static>

pub async fn connect(uri: &str) -> Result<Self, WebTonicError>

Connects the client to the endpoint.

Arguments

• uri: The uri to connect to. Note: The sceme is either ws:// or wss://, depending wether encryption is used or not.

Returns

• A Client on success.
• WebTonicError::InvalidUrl, if the url is malformed.
• WebTonicError::ConnectionError, if the endpoint can not be reached.

Example

let client = Client::connect("ws://localhost:1337").await.unwrap();

Trait Implementations

impl<'a> Clone for Client<'a>

fn clone(&self) -> Client<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Client<'a>

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

Formats the value using the given formatter.

impl<'a> GrpcService<BoxBody> for Client<'a>

type ResponseBody = BoxBody

Responses body given by the service.

type Error = WebTonicError

Errors produced by the service.

type Future = Pin<Box<dyn Future<Output = Result<Response<BoxBody>, WebTonicError>> + 'a>>

The future response value.

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

Returns Ready when the service is able to process requests.

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

Process the request and return the response asynchronously.