Struct RpcClient 

pub struct RpcClient<T, C: Codec = BincodeCodec>
where
    T: MessageChannel<C>,
{ /* private fields */ }

RPC client for making remote procedure calls.

Implementations

impl<T: MessageChannel<BincodeCodec> + 'static> RpcClient<T, BincodeCodec>

pub fn new(transport: T) -> Self

Examples found in repository

examples/rpc_client_server.rs (line 90)

async fn run_client() -> Result<(), Box<dyn std::error::Error>> {
    println!("[Client] Connecting to RPC server");

    let transport = SharedMemoryFrameTransport::connect_client(SERVICE_NAME)?;
    let channel = MessageChannelAdapter::new(transport);

    let client = RpcClient::new(channel);
    let handle = client.try_start()?;

    println!("[Client] Connected!\n");

    println!("[Client] Calling add(10, 32)");
    let resp: AddResponse = client.call("add", &AddRequest { a: 10, b: 32 }).await?;
    println!("[Client] Result: {}\n", resp.result);

    println!("[Client] Calling add(100, 200)");
    let resp: AddResponse = client.call("add", &AddRequest { a: 100, b: 200 }).await?;
    println!("[Client] Result: {}\n", resp.result);

    println!("[Client] Calling echo(\"Hello, RPC!\")");
    let resp: EchoResponse = client
        .call(
            "echo",
            &EchoRequest {
                message: "Hello, RPC!".to_string(),
            },
        )
        .await?;
    println!(
        "[Client] Result: message=\"{}\", length={}\n",
        resp.message, resp.length
    );

    println!("[Client] Calling unknown method");
    let result: Result<(), _> = client.call("unknown", &()).await;
    match result {
        Ok(_) => println!("[Client] Unexpected success"),
        Err(e) => println!("[Client] Got expected error: {}\n", e),
    }

    let close_result = client.close().await;
    let join_result = handle.join().await;
    close_result?;
    join_result?;
    println!("[Client] Done!");

    Ok(())
}

pub fn with_timeout(transport: T, default_timeout: Duration) -> Self

impl<T, C> RpcClient<T, C>

where T: MessageChannel<C> + 'static, C: Codec + Clone + Default + 'static,

pub fn with_codec(transport: T, codec: C) -> Self

pub fn with_codec_and_timeout( transport: T, codec: C, default_timeout: Duration, ) -> Self

pub fn start(&self) -> RpcClientHandle

Start the client’s background receive loop.

pub fn try_start(&self) -> Result<RpcClientHandle>

Start the background receive loop and reject duplicate or post-close startup.

Examples found in repository

examples/rpc_client_server.rs (line 91)

async fn run_client() -> Result<(), Box<dyn std::error::Error>> {
    println!("[Client] Connecting to RPC server");

    let transport = SharedMemoryFrameTransport::connect_client(SERVICE_NAME)?;
    let channel = MessageChannelAdapter::new(transport);

    let client = RpcClient::new(channel);
    let handle = client.try_start()?;

    println!("[Client] Connected!\n");

    println!("[Client] Calling add(10, 32)");
    let resp: AddResponse = client.call("add", &AddRequest { a: 10, b: 32 }).await?;
    println!("[Client] Result: {}\n", resp.result);

    println!("[Client] Calling add(100, 200)");
    let resp: AddResponse = client.call("add", &AddRequest { a: 100, b: 200 }).await?;
    println!("[Client] Result: {}\n", resp.result);

    println!("[Client] Calling echo(\"Hello, RPC!\")");
    let resp: EchoResponse = client
        .call(
            "echo",
            &EchoRequest {
                message: "Hello, RPC!".to_string(),
            },
        )
        .await?;
    println!(
        "[Client] Result: message=\"{}\", length={}\n",
        resp.message, resp.length
    );

    println!("[Client] Calling unknown method");
    let result: Result<(), _> = client.call("unknown", &()).await;
    match result {
        Ok(_) => println!("[Client] Unexpected success"),
        Err(e) => println!("[Client] Got expected error: {}\n", e),
    }

    let close_result = client.close().await;
    let join_result = handle.join().await;
    close_result?;
    join_result?;
    println!("[Client] Done!");

    Ok(())
}

pub fn transport(&self) -> Arc<T>

pub fn stream_manager(&self) -> Arc<StreamManager<C>>

pub async fn call<Req, Resp>(&self, method: &str, request: &Req) -> Result<Resp>

where Req: Serialize, Resp: for<'de> Deserialize<'de>,

Make a typed RPC call.

Examples found in repository

examples/rpc_client_server.rs (line 96)

async fn run_client() -> Result<(), Box<dyn std::error::Error>> {
    println!("[Client] Connecting to RPC server");

    let transport = SharedMemoryFrameTransport::connect_client(SERVICE_NAME)?;
    let channel = MessageChannelAdapter::new(transport);

    let client = RpcClient::new(channel);
    let handle = client.try_start()?;

    println!("[Client] Connected!\n");

    println!("[Client] Calling add(10, 32)");
    let resp: AddResponse = client.call("add", &AddRequest { a: 10, b: 32 }).await?;
    println!("[Client] Result: {}\n", resp.result);

    println!("[Client] Calling add(100, 200)");
    let resp: AddResponse = client.call("add", &AddRequest { a: 100, b: 200 }).await?;
    println!("[Client] Result: {}\n", resp.result);

    println!("[Client] Calling echo(\"Hello, RPC!\")");
    let resp: EchoResponse = client
        .call(
            "echo",
            &EchoRequest {
                message: "Hello, RPC!".to_string(),
            },
        )
        .await?;
    println!(
        "[Client] Result: message=\"{}\", length={}\n",
        resp.message, resp.length
    );

    println!("[Client] Calling unknown method");
    let result: Result<(), _> = client.call("unknown", &()).await;
    match result {
        Ok(_) => println!("[Client] Unexpected success"),
        Err(e) => println!("[Client] Got expected error: {}\n", e),
    }

    let close_result = client.close().await;
    let join_result = handle.join().await;
    close_result?;
    join_result?;
    println!("[Client] Done!");

    Ok(())
}

pub async fn call_with_timeout<Req, Resp>( &self, method: &str, request: &Req, timeout: Duration, ) -> Result<Resp>

where Req: Serialize, Resp: for<'de> Deserialize<'de>,

Make a typed RPC call with custom timeout.

pub async fn call_with_options<Req, Resp>( &self, method: &str, request: &Req, options: CallOptions, ) -> Result<Resp>

where Req: Serialize, Resp: for<'de> Deserialize<'de>,

Make a typed RPC call with explicit per-call options.

CallOptions::without_timeout disables only the application response deadline. The local wait still ends on explicit client close or terminal connection failure. Dropping the call future removes its local pending registration but does not cancel server work.

pub async fn call_server_stream<Req, Resp>( &self, method: &str, request: &Req, ) -> Result<StreamReceiver<Resp, C>>

where Req: Serialize, Resp: for<'de> Deserialize<'de>,

Initiate a server streaming RPC call.

pub async fn notify<Req: Serialize>( &self, method: &str, request: &Req, ) -> Result<()>

Send a one-way notification (no response expected).

pub async fn call_raw(&self, method: &str, payload: Vec<u8>) -> Result<Vec<u8>>

Make a raw bytes RPC call.

pub async fn call_raw_with_timeout( &self, method: &str, payload: Vec<u8>, timeout: Duration, ) -> Result<Vec<u8>>

Make a raw bytes RPC call with custom timeout.

pub async fn call_raw_with_options( &self, method: &str, payload: Vec<u8>, options: CallOptions, ) -> Result<Vec<u8>>

Make a raw bytes RPC call with explicit per-call options.

CallOptions::without_timeout disables only the application response deadline. The local wait remains interruptible by explicit client close, terminal connection failure, and future cancellation. These local events do not cancel server work.

pub fn is_connected(&self) -> bool

pub fn is_started(&self) -> bool

pub fn is_running(&self) -> bool

pub fn is_closed(&self) -> bool

pub fn active_streams(&self) -> usize

pub async fn close(&self) -> Result<()>

Examples found in repository

examples/rpc_client_server.rs (line 124)

async fn run_client() -> Result<(), Box<dyn std::error::Error>> {
    println!("[Client] Connecting to RPC server");

    let transport = SharedMemoryFrameTransport::connect_client(SERVICE_NAME)?;
    let channel = MessageChannelAdapter::new(transport);

    let client = RpcClient::new(channel);
    let handle = client.try_start()?;

    println!("[Client] Connected!\n");

    println!("[Client] Calling add(10, 32)");
    let resp: AddResponse = client.call("add", &AddRequest { a: 10, b: 32 }).await?;
    println!("[Client] Result: {}\n", resp.result);

    println!("[Client] Calling add(100, 200)");
    let resp: AddResponse = client.call("add", &AddRequest { a: 100, b: 200 }).await?;
    println!("[Client] Result: {}\n", resp.result);

    println!("[Client] Calling echo(\"Hello, RPC!\")");
    let resp: EchoResponse = client
        .call(
            "echo",
            &EchoRequest {
                message: "Hello, RPC!".to_string(),
            },
        )
        .await?;
    println!(
        "[Client] Result: message=\"{}\", length={}\n",
        resp.message, resp.length
    );

    println!("[Client] Calling unknown method");
    let result: Result<(), _> = client.call("unknown", &()).await;
    match result {
        Ok(_) => println!("[Client] Unexpected success"),
        Err(e) => println!("[Client] Got expected error: {}\n", e),
    }

    let close_result = client.close().await;
    let join_result = handle.join().await;
    close_result?;
    join_result?;
    println!("[Client] Done!");

    Ok(())
}

Trait Implementations

impl<T, C> Debug for RpcClient<T, C>

where T: MessageChannel<C>, C: Codec + Clone,

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

Formats the value using the given formatter.

impl<T, C> Drop for RpcClient<T, C>

where T: MessageChannel<C>, C: Codec,

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.