Struct webtonic_client::Client

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

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>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

pub 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 = LocalBoxFuture<'a, Result<Response<BoxBody>, WebTonicError>>

The future response value.

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

Returns Ready when the service is able to process requests.

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

Process the request and return the response asynchronously.