occams-rpc 0.3.0

razor-rpc is a modular, pluggable RPC for high throughput scenario, supports various runtimes, with a low-level streaming interface, and high-level remote API call interface.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

use super::task::APIServerReq;
use crate::{Codec, error::RpcIntErr};
use rustc_hash::FxHashMap;
use std::sync::Arc;

/// Service handling code generated by macro
///
/// A ServiceStatic can be acquired by:
/// - `Arc<T>` where `T: ServiceStatic`,
/// - attr macro [service](crate::server::service): a class with multi method, if only one service, ignore [APIServerReq::service].
/// - attr macro [service_mux_struct](crate::server::service_mux_struct): a struct that contains several service, match [APIServerReq::service] by [ServiceStatic::SERVICE_NAME] field,
/// - [ServiceMuxDyn]: match multiple `dyn ServiceDyn` with SERVICE_NAME  (ServiceStatic auto impl [ServiceDyn])
pub trait ServiceStatic<C: Codec>: Send + Sync + 'static + Sized {
    /// For server_mux_struct to match
    const SERVICE_NAME: &'static str;

    /// the [`#[service]`](crate::server::service) macro should generate code like this:
    /// ```no_compile
    /// match req.method
    ///     match req.decode::<RequestType>() {
    ///         Err(())=>{
    ///             req.set_rpc_error(razor_rpc_core::error::RpcIntErr::Decode);
    ///             returnl
    ///         }
    ///         Ok(arg)=>{
    ///             match self.#method(arg).await {
    ///                 Ok(resp)=>{
    ///                     req.set_result(resp);
    ///                 }
    ///                 Err(e)=>{
    ///                     req.set_error::<E: RpcErrCodec>(e)
    ///                 }
    ///             }
    ///         }
    ///     }
    /// ```
    fn serve(&self, req: APIServerReq<C>) -> impl Future<Output = ()> + Send + Sized;
}

impl<S: ServiceStatic<C>, C: Codec> ServiceStatic<C> for Arc<S> {
    const SERVICE_NAME: &'static str = S::SERVICE_NAME;

    #[inline(always)]
    fn serve(&self, req: APIServerReq<C>) -> impl Future<Output = ()> + Send + Sized {
        self.as_ref().serve(req)
    }
}

/// Service trait for dyn dispatch, used by [ServiceMuxDyn]
///
/// NOTE:
/// - [ServiceStatic] auto impl `ServiceDyn`
/// - It cannot be used by [service_mux_struct](crate::server::service_mux_struct)
#[async_trait::async_trait]
pub trait ServiceDyn<C: Codec>: Send + Sync + 'static {
    fn get_service_name(&self) -> &'static str;

    async fn serve_dyn(&self, req: APIServerReq<C>);
}

#[async_trait::async_trait]
impl<S: ServiceStatic<C>, C: Codec> ServiceDyn<C> for S {
    #[inline(always)]
    fn get_service_name(&self) -> &'static str {
        <Self as ServiceStatic<C>>::SERVICE_NAME
    }

    #[inline(always)]
    async fn serve_dyn(&self, req: APIServerReq<C>) {
        self.serve(req).await
    }
}

/// A Service mux dispatch with hashmap
///
/// Only accepts ServiceDyn register, but provide ServiceDyn and ServiceStatic for calling
pub struct ServiceMuxDyn<C: Codec> {
    map: FxHashMap<&'static str, Arc<dyn ServiceDyn<C>>>,
}

impl<C: Codec> ServiceMuxDyn<C> {
    #[inline]
    pub fn new() -> Self {
        Self { map: Default::default() }
    }

    #[inline]
    pub fn add(&mut self, service: Arc<dyn ServiceDyn<C>>) {
        self.map.insert(service.get_service_name(), service);
    }
}

impl<C: Codec> ServiceStatic<C> for ServiceMuxDyn<C> {
    const SERVICE_NAME: &'static str = "";

    #[inline(always)]
    fn serve(&self, req: APIServerReq<C>) -> impl Future<Output = ()> + Send + Sized {
        async move {
            if let Some(service) = self.map.get(req.service.as_str()) {
                service.serve_dyn(req).await
            } else {
                req.set_rpc_error(RpcIntErr::Service);
            }
        }
    }
}