Struct Client

pub struct Client { /* private fields */ }

A client that sends requests and notifications to a remote MessagePack-RPC server.

Implementations

impl Client

pub fn new<T: AsyncRead + AsyncWrite + 'static + Send>(stream: T) -> Self

Creates a new Client that can be used to send requests and notifications on the given stream.

use std::io;
use std::net::SocketAddr;

use rmp_rpc::Client;
use tokio::net::TcpStream;
use tokio_util::compat::TokioAsyncReadCompatExt;

let addr: SocketAddr = "127.0.0.1:54321".parse().unwrap();

let f = async {
    // Create a future that connects to the server, and send a notification and a request.
    let socket = TcpStream::connect(&addr).await?;
    let client = Client::new(socket.compat());

    // Use the client to send a notification.
    // The future returned by client.notify() finishes when the notification
    // has been sent, in case we care about that. We can also just drop it.
    client.notify("hello", &[]);

    // Use the client to send a request with the method "dostuff", and two parameters:
    // the string "foo" and the integer "42".
    // The future returned by client.request() finishes when the response
    // is received.
    if let Ok(resp) = client.request("dostuff", &["foo".into(), 42.into()]).await {
        println!("Response: {:?}", resp);
    }
    Ok::<_, io::Error>(())
};

// Uncomment this to run the client, blocking until the response was received and the
// message was printed.
// tokio::run(f);

Panics

This function will panic if the default executor is not set or if spawning onto the default executor returns an error. To avoid the panic, use

DefaultExecutor

pub fn request(&self, method: &str, params: &[Value]) -> Response

Send a MessagePack-RPC request

pub fn notify(&self, method: &str, params: &[Value]) -> Ack

Send a MessagePack-RPC notification

Trait Implementations

impl Clone for Client

fn clone(&self) -> Client

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Future for Client

type Output = Result<(), Error>

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output>

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.