Struct toy_rpc::client::async_std::Client

pub struct Client<Mode> { /* fields omitted */ }

RPC Client. Unlike Server, the Client struct contains field that uses runtime dependent synchronization primitives, thus there is a separate ‘Client’ struct defined for each of the async-std and tokio runtime.

Implementations

impl Client<NotConnected>

The following impl block is controlled by feature flag. It is enabled if and only if exactly one of the the following feature flag is turned on

• serde_bincode
• serde_json
• serde_cbor
• serde_rmp

pub async fn dial(addr: impl ToSocketAddrs) -> Result<Client<Connected>, Error>

Connects the an RPC server over socket at the specified network address

This is enabled if and only if exactly one of the the following feature flag is turned on

• serde_bincode
• serde_json
• serde_cbor
• serde_rmp

Example

use toy_rpc::Client;

#[async_std::main]
async fn main() {
    let addr = "127.0.0.1:8080";
    let client = Client::dial(addr).await;
}

pub async fn dial_websocket(addr: &str) -> Result<Client<Connected>, Error>

Similar to dial, this connects to an WebSocket RPC server at the specified network address using the defatul codec

This is enabled if and only if exactly one of the the following feature flag is turned on

• serde_bincode
• serde_json
• serde_cbor
• serde_rmp

Example

use toy_rpc::client::Client;

#[async_std::main]
async fn main() {
    let addr = "ws://127.0.0.1:8080";
    let client = Client::dial_http(addr).await.unwrap();
}

pub async fn dial_http(addr: &str) -> Result<Client<Connected>, Error>

Connects to an HTTP RPC server at the specified network address using WebSocket and the defatul codec.

It is recommended to use “ws://” as the url scheme as opposed to “http://”; however, internally the url scheme is changed to “ws://”. Internally, DEFAULT_RPC_PATH="_rpc" is appended to the end of addr, and the rest is the same is calling dial_websocket. If a network path were to be supplpied, the network path must end with a slash “/”. For example, a valid path could be “ws://127.0.0.1/rpc/”.

Warning: WebSocket is used as the underlying transport protocol starting from version “0.5.0-beta.0”, and this will make client of versions later than “0.5.0-beta.0” incompatible with servers of versions earlier than “0.5.0-beta.0”.

This is enabled if and only if only one of the the following feature flag is turned on

• serde_bincode
• serde_json
• serde_cbor
• serde_rmp

Example

use toy_rpc::Client;

#[async_std::main]
async fn main() {
    let addr = "ws://127.0.0.1:8080/rpc/";
    let client = Client::dial_http(addr).await.unwrap();
}

pub fn with_stream<T>(stream: T) -> Client<Connected> where
    T: AsyncRead + AsyncWrite + Send + Sync + Unpin + 'static, 

Creates an RPC Client over socket with a specified async_std::net::TcpStream and the default codec

This is enabled if and only if exactly one of the the following feature flag is turned on

• serde_bincode
• serde_json
• serde_cbor
• serde_rmp

Example

use async_std::net::TcpStream;
use toy_rpc::Client;

#[async_std::main]
async fn main() {
    let stream = TcpStream::connect("127.0.0.1:8080").await.unwrap();
    let client = Client::with_stream(stream);
}

impl Client<NotConnected>

pub fn with_codec<C>(codec: C) -> Client<Connected> where
    C: ClientCodec + Send + Sync + 'static, 

Creates an RPC ’Clientwith a specified codec. The codec must implementClientCodectrait andGracefulShutdown` trait.

Example

use async_std::net::TcpStream;
use toy_rpc::codec::bincode::Codec;
use toy_rpc::Client;

#[async_std::main]
async fn main() {
    let addr = "127.0.0.1:8080";
    let stream = TcpStream::connect(addr).await.unwrap();
    let codec = Codec::new(stream);
    let client = Client::with_codec(codec);
}

impl Client<Connected>

pub fn call<Req, Res>(
    &self,
    service_method: impl ToString,
    args: Req
) -> Result<Res, Error> where
    Req: Serialize + Send + Sync,
    Res: DeserializeOwned, 

Invokes the named function and wait synchronously in a blocking manner.

This function internally calls task::block_on to wait for the response. Do NOT use this function inside another task::block_on.async_std

Example

use toy_rpc::Client;

#[async_std::main]
async fn main() {
    let addr = "127.0.0.1:8080";
    let client = Client::dial(addr).await.unwrap();

    let args = "arguments";
    let reply: Result<String, Error> = client.call("EchoService.echo", &args);
    println!("{:?}", reply);
}

pub fn spawn_task<Req, Res>(
    &self,
    service_method: impl ToString + Send + 'static,
    args: Req
) -> JoinHandle<Result<Res, Error>> where
    Req: Serialize + Send + Sync + 'static,
    Res: DeserializeOwned + Send + 'static, 

Invokes the named function asynchronously by spawning a new task and returns the JoinHandle

use async_std::task;

use toy_rpc::client::Client;
use toy_rpc::error::Error;

#[async_std::main]
async fn main() {
    let addr = "127.0.0.1:8080";
    let client = Client::dial(addr).await.unwrap();

    let args = "arguments";
    let handle: task::JoinHandle<Result<Res, Error>> = client.spawn_task("EchoService.echo", args);
    let reply: Result<String, Error> = handle.await;
    println!("{:?}", reply);
}

pub async fn async_call<Req, Res>(
    &self,
    service_method: impl ToString,
    args: Req
) -> Result<Res, Error> where
    Req: Serialize + Send + Sync,
    Res: DeserializeOwned, 

Invokes the named function asynchronously

Example

use toy_rpc::Client;
use toy_rpc::error::Error;

#[async_std::main]
async fn main() {
    let addr = "127.0.0.1:8080";
    let client = Client::dial(addr).await.unwrap();

    let args = "arguments";
    let reply: Result<String, Error> = client.async_call("EchoService.echo", &args).await;
    println!("{:?}", reply);
}

pub async fn close(self)

Gracefully shutdown the connection.

For a WebSocket connection, a Close message will be sent. For a raw TCP connection, the client will simply drop the connection