Struct datacake_rpc::RpcClient

pub struct RpcClient<Svc>where
    Svc: RpcService,{ /* private fields */ }

A RPC client handle for a given service.

use bytecheck::CheckBytes;
use rkyv::{Archive, Deserialize, Serialize};
use datacake_rpc::{Handler, Request, RpcService, ServiceRegistry, Status, RpcClient, Channel};
use std::net::SocketAddr;

#[repr(C)]
#[derive(Serialize, Deserialize, Archive, PartialEq, Debug)]
#[archive(compare(PartialEq))]
#[archive_attr(derive(CheckBytes, PartialEq, Debug))]
pub struct MyMessage {
    name: String,
    age: u32,
}

pub struct EchoService;

impl RpcService for EchoService {
    fn register_handlers(registry: &mut ServiceRegistry<Self>) {
        registry.add_handler::<MyMessage>();
    }
}

#[datacake_rpc::async_trait]
impl Handler<MyMessage> for EchoService {
    type Reply = MyMessage;

    async fn on_message(&self, msg: Request<MyMessage>) -> Result<Self::Reply, Status> {
        Ok(msg.to_owned().unwrap())
    }
}

let connect = "127.0.0.1:8000".parse::<SocketAddr>()?;
let client = Channel::connect(connect);

let rpc_client = RpcClient::<EchoService>::new(client);

let msg = MyMessage {
    name: "Bobby".to_string(),
    age: 12,
};

let resp = rpc_client.send(&msg).await?;
assert_eq!(resp, msg);

Implementations

impl<Svc> RpcClient<Svc>where
    Svc: RpcService,

pub fn new(channel: Channel) -> Self

Creates a new RPC client which can handle a new service type.

RpcClient’s are cheap to create and should be preferred over locking or other synchronization primitives.

pub fn new_client<Svc2>(&self) -> RpcClient<Svc2>where
    Svc2: RpcService,

Creates a new RPC client which can handle a new service type.

RpcClient’s are cheap to create and should be preferred over locking or other synchronization primitives.

pub async fn send<Msg>(
    &self,
    msg: &Msg
) -> Result<MessageReply<Svc, Msg>, Status>where
    Msg: Archive + Serialize<AllocSerializer<SCRATCH_SPACE>>,
    Msg::Archived: CheckBytes<DefaultValidator<'static>> + 'static,
    Svc: Handler<Msg>,
    <Svc as Handler<Msg>>::Reply: Archive + Serialize<AllocSerializer<SCRATCH_SPACE>>,
    <<Svc as Handler<Msg>>::Reply as Archive>::Archived: CheckBytes<DefaultValidator<'static>> + 'static,

Sends a message to the server and wait for a reply.

Trait Implementations

impl<Svc> Clone for RpcClient<Svc>where
    Svc: RpcService,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.