ezrpc 0.1.1

Ergonomic, flexible and Zero-cost RPC framework
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

use anyhow::Context;
use rmp::decode;
use serde::{de::DeserializeOwned, Deserialize, Serializer};
use std::error::Error as StdError;
use std::ops::RangeFrom;

pub const REQUEST: u32 = 0; // Caller->Callee [REQUEST, ID: u32, METHOD: u32, ARGS: Any]
pub const RESPONSE: u32 = 1; // Callee->Caller [RESPONSE, ID: u32, ERROR: Option<String>, RESULT: Any]
pub const NOTIFY: u32 = 2; // Caller->Callee [NOTIFY, METHOD: u32, ARGS: Any]
pub const RESPONSE_STREAM: u32 = 3; // Callee->Caller [RESPONSE_STREAM, ID: u32, END: bool, RESULT: Any]

/// Represents a packet unit for ezrpc
pub struct Packet {
    pub(crate) meta: PackMeta,
    pack: Vec<u8>,
    dref: RangeFrom<usize>,
}

/// The type of RPC method id, is commonly string or integer, but can be any serializable types
pub type Method = serde_value::Value;

#[doc(hidden)]
#[derive(Debug, Clone)]
pub enum PackMeta {
    Notify { method: Method },
    Request { method: Method, req: u32 },
    Response { req: u32, error: Option<Box<str>> },
    Stream { req: u32, finished: bool },
}

impl Packet {
    pub fn from_pack(pack: Vec<u8>) -> anyhow::Result<Self> {
        let mut reader = &pack[..];
        let start_ptr = reader.as_ptr() as usize;
        let len = decode::read_array_len(&mut reader).context("len")?;
        let pack_type: u32 = decode::read_int(&mut reader).context("type")?;

        Ok(match pack_type {
            REQUEST => {
                assert_eq!(len, 4);
                let req: u32 = decode::read_int(&mut reader).context("reqid")?;
                let method = rmp_serde::decode::from_read(&mut reader).context("method")?;

                Self {
                    meta: PackMeta::Request { method, req },
                    dref: reader.as_ptr() as usize - start_ptr..,
                    pack,
                }
            }
            NOTIFY => {
                assert_eq!(len, 3);
                let method = rmp_serde::decode::from_read(&mut reader).context("method")?;

                Self {
                    meta: PackMeta::Notify { method },
                    dref: reader.as_ptr() as usize - start_ptr..,
                    pack,
                }
            }
            RESPONSE => {
                assert_eq!(len, 4);
                let req: u32 = decode::read_int(&mut reader).context("reqid")?;
                let error = rmpv::decode::read_value(&mut reader).context("method")?;
                Self {
                    meta: PackMeta::Response {
                        req,
                        error: error.as_str().map(Into::into),
                    },
                    dref: reader.as_ptr() as usize - start_ptr..,
                    pack,
                }
            }
            RESPONSE_STREAM => {
                assert_eq!(len, 4);
                let req: u32 = decode::read_int(&mut reader).context("reqid")?;
                let finished = decode::read_bool(&mut reader).context("finished")?;
                Self {
                    meta: PackMeta::Stream { req, finished },
                    dref: reader.as_ptr() as usize - start_ptr..,
                    pack,
                }
            }
            _ => unreachable!(),
        })
    }

    /// Data part in the packet
    #[inline(always)]
    pub fn data(&self) -> &[u8] {
        &self.pack[self.dref.clone()]
    }

    /// Get error message in the response packet
    pub fn error(&self) -> Option<&str> {
        match &self.meta {
            PackMeta::Response { error, .. } => error.as_ref().map(AsRef::as_ref),
            _ => None,
        }
    }

    /// Deserialize the data in the packet
    #[inline(always)]
    pub fn decode<'a, T: Deserialize<'a>>(&'a self) -> Result<T, impl StdError> {
        rmp_serde::from_slice(self.data())
    }

    #[inline(always)]
    pub fn decode_to<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
        serde_transcode::transcode(&mut rmp_serde::Deserializer::new(self.data()), s)
    }

    /// Get the RPC method in the notify/request packet
    pub fn method(&self) -> Option<&Method> {
        match &self.meta {
            PackMeta::Notify { method } => Some(method),
            PackMeta::Request { method, .. } => Some(method),
            _ => None,
        }
    }

    /// Get the request id
    pub fn request_id(&self) -> Option<u32> {
        match self.meta {
            PackMeta::Request { req, .. } => Some(req),
            PackMeta::Response { req, .. } => Some(req),
            _ => None,
        }
    }
}

/// Trait for types which can be converted by a Packet
pub trait FromPacket: Sized {
    fn from_packet(pack: Packet) -> anyhow::Result<Self>;
}

impl<T: DeserializeOwned + 'static> FromPacket for T {
    fn from_packet(pack: Packet) -> anyhow::Result<Self> {
        match pack.error() {
            Some(err) => Err(anyhow::Error::msg(err.to_string())),
            None => Ok(pack.decode()?),
        }
    }
}

impl FromPacket for Packet {
    fn from_packet(pack: Packet) -> anyhow::Result<Self> {
        Ok(pack)
    }
}