一个用于真正零拷贝消息处理的类似演员的 RPC 框架。

一个用于真正零拷贝消息处理的类似演员的 RPC 框架。

该框架受 tonic 启发，但不是 GRPC 框架。相反，它利用了令人难以置信的 rkyv（反）序列化框架，该框架为我们提供了闪电般的（反）序列化速度，并允许我们执行真正的零拷贝反序列化，这可以在一次处理大量大消息时带来巨大的性能提升。

特性

• 拥有类型的快速（反）序列化。
• 真正的零拷贝反序列化，避免大量分配。
• 动态添加和删除消息处理器/服务。

基本示例

use std::net::SocketAddr;                                                                      
                                                                                                
use datacake_rpc::{                                                                             
    Channel,                                                                                    
    Handler,                                                                                    
    Request,                                                                                    
    RpcClient,                                                                                  
    RpcService,                                                                                 
    Server,                                                                                     
    ServiceRegistry,                                                                            
    Status,                                                                                     
};                                                                                              
use rkyv::{Archive, Deserialize, Serialize};                                                    
                                                                                                
// The framework accepts any messages which implement `Archive` and `Serialize` along           
// with the archived values implementing `CheckBytes` from the `bytecheck` crate.               
// This is to ensure safe, validated deserialization of the values.                             
//                                                                                              
// Checkout rkyv for more information!                                                          
#[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 MyService;                                                                           
                                                                                                
impl RpcService for MyService {                                                                 
    // The `register_handlers` is used to mark messages as something                            
    // the given service can handle and process.                                                
    //                                                                                          
    // Messages which are not registered will not be dispatched to the handler.                 
    fn register_handlers(registry: &mut ServiceRegistry<Self>) {                                
        registry.add_handler::<MyMessage>();                                                    
    }                                                                                           
}                                                                                               
                                                                                                
#[datacake_rpc::async_trait]                                                                    
impl Handler<MyMessage> for MyService {                                                         
    type Reply = String;                                                                        
                                                                                                
    // Our `Request` gives us a zero-copy view to our message, this doesn't actually            
    // allocate the message type.                                                               
    async fn on_message(&self, msg: Request<MyMessage>) -> Result<Self::Reply, Status> {        
        Ok(msg.to_owned().unwrap().name)                                                        
    }                                                                                           
}                                                                                               
                                                                                                
#[tokio::main]                                                                                  
async fn main() -> anyhow::Result<()> {                                                         
    let address = "127.0.0.1:8000".parse::<SocketAddr>()?;                                      
                                                                                                
    let server = Server::listen(address).await?;                                                
    // Services can be added and removed at runtime once the server is started.                 
    server.add_service(MyService);                                                              
    println!("Listening to address {}!", address);                                              
                                                                                                
    // Channels are cheap to clone similar to tonic.                                            
    let client = Channel::connect(address);                                              
    println!("Connected to address {}!", address);                                              
                                                                                                
    let rpc_client = RpcClient::<MyService>::new(client);                                   
                                                                                                
    let msg1 = MyMessage {                                                                      
        name: "Bobby".to_string(),                                                              
        age: 12,                                                                                
    };                                                                                          
                                                                                                
    // Clients only need references to the message which helps                                  
    // reduce allocations.                                                                      
    let resp = rpc_client.send(&msg1).await?;                                                   
    assert_eq!(resp, msg1.name);                                                                     
    Ok(())                                                                                      
}