Struct datacake_rpc::ServiceRegistry

pub struct ServiceRegistry<Svc> { /* private fields */ }

A registry system used for linking a service’s message handlers with the RPC system at runtime.

Since the RPC system cannot determine what message payload matches with which handler at compile time, it must dynamically link them at runtime.

Not registering a handler will cause the handler to not be triggered even if a valid message comes through.

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, Debug)]
#[archive_attr(derive(CheckBytes, Debug))]
pub struct MyMessage {
    name: String,
    age: u32,
}

#[repr(C)]
#[derive(Serialize, Deserialize, Archive, Debug)]
#[archive_attr(derive(CheckBytes, Debug))]
pub struct MyOtherMessage {
    age: u32,
}

pub struct EchoService;

impl RpcService for EchoService {
    fn register_handlers(registry: &mut ServiceRegistry<Self>) {
        // Since we've registered the `MyMessage` handler, the RPC system
        // will dispatch the messages to out handler.
        //
        // But because we *haven't* registered our `MyOtherMessage` handler,
        // even though our service implements the handler, no messages will
        // be dispatched.
        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())
    }
}

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

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

Implementations

impl<Svc> ServiceRegistry<Svc>where
    Svc: RpcService + Send + Sync + 'static,

pub fn add_handler<Msg>(&mut self)where
    Msg: Archive + Send + Sync + 'static,
    Msg::Archived: CheckBytes<DefaultValidator<'static>> + Send + Sync + 'static,
    Svc: Handler<Msg>,

Adds a new handler to the registry.

This is done in the form of specifying what message types are handled by the service via the generic.