edgy-s 1.4.0

A minimalist WebSocket bidirectional RPC framework for building microservice applications
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

#[cfg(any(feature = "postcard", feature = "cbor4", feature = "serde_json"))]
use ser_impl::{from_bytes, to_bytes};
use {
    super::ReqId,
    serde::{Deserialize, Serialize},
    std::io::{Error as IoError, Result as IoResult},
    tokio_tungstenite::tungstenite::Message,
};

/// --- postcard serialization backend (highest priority) ---
#[cfg(feature = "postcard")]
mod ser_impl {
    use {
        super::*,
        postcard::{from_bytes as from_slice, to_allocvec},
    };

    pub(super) fn to_bytes<T: Serialize>(value: &T) -> IoResult<Vec<u8>> {
        to_allocvec(value).map_err(IoError::other)
    }

    pub(super) fn from_bytes<'de, T: Deserialize<'de>>(bytes: &'de [u8]) -> IoResult<T> {
        from_slice(bytes).map_err(IoError::other)
    }
}

/// --- cbor4 serialization backend (medium priority) ---
#[cfg(all(feature = "cbor4", not(feature = "postcard")))]
mod ser_impl {
    use {
        super::*,
        cbor4ii::serde::{from_slice, to_vec},
    };

    pub(super) fn to_bytes<T: Serialize>(value: &T) -> IoResult<Vec<u8>> {
        to_vec(Vec::new(), value).map_err(IoError::other)
    }

    pub(super) fn from_bytes<'de, T: Deserialize<'de>>(bytes: &'de [u8]) -> IoResult<T> {
        from_slice(bytes).map_err(IoError::other)
    }
}

/// --- serde_json serialization backend (lowest priority) ---
#[cfg(all(
    feature = "serde_json",
    not(any(feature = "postcard", feature = "cbor4"))
))]
mod ser_impl {
    use {
        super::*,
        serde_json::{from_slice, to_vec},
    };

    pub(super) fn to_bytes<T: Serialize>(value: &T) -> IoResult<Vec<u8>> {
        to_vec(value).map_err(IoError::other)
    }

    pub(super) fn from_bytes<'de, T: Deserialize<'de>>(bytes: &'de [u8]) -> IoResult<T> {
        from_slice(bytes).map_err(IoError::other)
    }
}

// --- No serialization backend enabled ---
#[cfg(not(any(feature = "postcard", feature = "cbor4", feature = "serde_json")))]
compile_error!(
    "No serialization backend enabled. \
     Please enable one of: `postcard` (default, compact), `cbor4` (CBOR format), or `serde_json` (JSON format)."
);

#[cfg_attr(
    any(feature = "postcard", feature = "cbor4", feature = "serde_json"),
    derive(Deserialize, Serialize)
)]
#[derive(Debug, PartialEq)]
pub enum Packet<A, B> {
    Call(ReqId, A),
    Ret(ReqId, B),
}

unsafe impl<A, B> Send for Packet<A, B> {}

impl<A, B> Packet<A, B> {
    pub fn from_message(message: &Message) -> IoResult<Self>
    where
        A: for<'a> Deserialize<'a>,
        B: for<'a> Deserialize<'a>,
    {
        match message {
            #[cfg(any(feature = "postcard", feature = "cbor4", feature = "serde_json"))]
            Message::Binary(bytes) => from_bytes(bytes),
            _ => Err(IoError::other(
                "Unsupported message. Please try to change other serialization backend.",
            )),
        }
    }

    #[cfg(any(feature = "postcard", feature = "cbor4", feature = "serde_json"))]
    pub fn make_ret_message(id: ReqId, data: B) -> IoResult<Message>
    where
        A: Serialize,
        B: Serialize,
    {
        Ok(Message::Binary(to_bytes(&Self::Ret(id, data))?.into()))
    }

    #[cfg(not(any(feature = "postcard", feature = "cbor4", feature = "serde_json")))]
    pub fn make_ret_message(_id: ReqId, _data: B) -> IoResult<Message>
    where
        A: Serialize,
        B: Serialize,
    {
        unimplemented!("Please enable `postcard`, `cbor4` or `serde_json` feature.")
    }

    #[cfg(any(feature = "postcard", feature = "cbor4", feature = "serde_json"))]
    pub fn make_call_message(id: ReqId, data: A) -> IoResult<Message>
    where
        A: Serialize,
        B: Serialize,
    {
        Ok(Message::Binary(to_bytes(&Self::Call(id, data))?.into()))
    }

    #[cfg(not(any(feature = "postcard", feature = "cbor4", feature = "serde_json")))]
    pub fn make_call_message(_id: ReqId, _data: A) -> IoResult<Message>
    where
        A: Serialize,
        B: Serialize,
    {
        unimplemented!("Please enable `postcard`, `cbor4` or `serde_json` feature.")
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_packet() -> anyhow::Result<()> {
        let data = Packet::<(), i32>::make_ret_message(100 as ReqId, 3)?;
        let ret = Packet::<(), i32>::from_message(&data)?;
        assert_eq!(ret, Packet::Ret(100 as ReqId, 3));

        Ok(())
    }
}