Struct Server

pub struct Server { /* private fields */ }

A RPC server instance.

This is used for listening for inbound connections and handling any RPC messages coming from clients.

use rkyv::{Archive, Deserialize, Serialize};
use datacake_rpc::{Server, Handler, Request, RpcService, ServiceRegistry, Status};
use std::net::SocketAddr;

#[repr(C)]
#[derive(Serialize, Deserialize, Archive, PartialEq, Debug)]
#[archive(compare(PartialEq), check_bytes)]
#[archive_attr(derive(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 bind = "127.0.0.1:8000".parse::<SocketAddr>()?;
// Start the RPC server listening on our bind address.
let server = Server::listen(bind).await?;

// Once our server is running we can add or remove services.
// Once a service is added it is able to begin handling RPC messages.
server.add_service(EchoService);

// Once a service is removed the server will reject messages for the
// service that is no longer registered,
server.remove_service(EchoService::service_name());

// We can add wait() here if we want to listen for messages forever.
// server.wait().await;

Implementations

impl Server

pub async fn listen(addr: SocketAddr) -> Result<Self>

Spawns the RPC server task and returns the server handle.

pub fn add_service<Svc>(&self, service: Svc)

where Svc: RpcService + Send + Sync + 'static,

Adds a new service to the live RPC server.

pub fn remove_service(&self, service_name: &str)

Removes all handlers linked with the given service name.

pub fn shutdown(self)

Signals the server to shutdown.

pub async fn wait(self)

Waits until the server exits.

This typically is just a future that pends forever as the server will not exit unless an external force triggers it.