rings_rpc/protos/
rings_node_handler.rs

1use std::sync::Arc;
2
3use async_trait::async_trait;
4use jsonrpc_core::types::error::Error;
5use jsonrpc_core::types::error::ErrorCode;
6use jsonrpc_core::Result;
7
8use super::rings_node::*;
9use crate::method::Method;
10
11/// Used for processor to match rpc request and response.
12#[cfg_attr(feature = "wasm", async_trait(?Send))]
13#[cfg_attr(not(feature = "wasm"), async_trait)]
14pub trait HandleRpc<Req, Resp> {
15    /// Handle rpc request and return response.
16    async fn handle_rpc(&self, req: Req) -> Result<Resp>;
17}
18
19/// Provide handle_request method for internal rpc api.
20#[derive(Clone, Copy)]
21pub struct InternalRpcHandler;
22
23/// Provide handle_request method for external rpc api.
24#[derive(Clone, Copy)]
25pub struct ExternalRpcHandler;
26
27impl InternalRpcHandler {
28    /// Handle rpc request.
29    pub async fn handle_request<P>(
30        &self,
31        processor: Arc<P>,
32        method: String,
33        params: serde_json::Value,
34    ) -> Result<serde_json::Value>
35    where
36        P: HandleRpc<ConnectPeerViaHttpRequest, ConnectPeerViaHttpResponse>
37            + HandleRpc<ConnectWithDidRequest, ConnectWithDidResponse>
38            + HandleRpc<ConnectWithSeedRequest, ConnectWithSeedResponse>
39            + HandleRpc<ListPeersRequest, ListPeersResponse>
40            + HandleRpc<CreateOfferRequest, CreateOfferResponse>
41            + HandleRpc<AnswerOfferRequest, AnswerOfferResponse>
42            + HandleRpc<AcceptAnswerRequest, AcceptAnswerResponse>
43            + HandleRpc<DisconnectRequest, DisconnectResponse>
44            + HandleRpc<SendBackendMessageRequest, SendBackendMessageResponse>
45            + HandleRpc<SendE2eHandshakeRequest, SendE2eHandshakeResponse>
46            + HandleRpc<SendE2eMessageRequest, SendE2eMessageResponse>
47            + HandleRpc<PublishMessageToTopicRequest, PublishMessageToTopicResponse>
48            + HandleRpc<FetchTopicMessagesRequest, FetchTopicMessagesResponse>
49            + HandleRpc<RegisterServiceRequest, RegisterServiceResponse>
50            + HandleRpc<LookupServiceRequest, LookupServiceResponse>
51            + HandleRpc<NodeInfoRequest, NodeInfoResponse>
52            + HandleRpc<NodeDidRequest, NodeDidResponse>,
53    {
54        let method = Method::try_from(method.as_str()).map_err(|_| Error {
55            code: ErrorCode::MethodNotFound,
56            message: format!("method {method} is not found"),
57            data: None,
58        })?;
59
60        match method {
61            Method::ConnectPeerViaHttp => {
62                let req = serde_json::from_value::<ConnectPeerViaHttpRequest>(params)
63                    .map_err(|e| Error::invalid_params(e.to_string()))?;
64                let resp = processor.handle_rpc(req).await?;
65                serde_json::to_value(resp).map_err(|_| Error::new(ErrorCode::ParseError))
66            }
67            Method::ConnectWithDid => {
68                let req = serde_json::from_value::<ConnectWithDidRequest>(params)
69                    .map_err(|e| Error::invalid_params(e.to_string()))?;
70                let resp = processor.handle_rpc(req).await?;
71                serde_json::to_value(resp).map_err(|_| Error::new(ErrorCode::ParseError))
72            }
73            Method::ConnectWithSeed => {
74                let req = serde_json::from_value::<ConnectWithSeedRequest>(params)
75                    .map_err(|e| Error::invalid_params(e.to_string()))?;
76                let resp = processor.handle_rpc(req).await?;
77                serde_json::to_value(resp).map_err(|_| Error::new(ErrorCode::ParseError))
78            }
79            Method::ListPeers => {
80                let req = serde_json::from_value::<ListPeersRequest>(params)
81                    .map_err(|e| Error::invalid_params(e.to_string()))?;
82                let resp = processor.handle_rpc(req).await?;
83                serde_json::to_value(resp).map_err(|_| Error::new(ErrorCode::ParseError))
84            }
85            Method::CreateOffer => {
86                let req = serde_json::from_value::<CreateOfferRequest>(params)
87                    .map_err(|e| Error::invalid_params(e.to_string()))?;
88                let resp = processor.handle_rpc(req).await?;
89                serde_json::to_value(resp).map_err(|_| Error::new(ErrorCode::ParseError))
90            }
91            Method::AnswerOffer => {
92                let req = serde_json::from_value::<AnswerOfferRequest>(params)
93                    .map_err(|e| Error::invalid_params(e.to_string()))?;
94                let resp = processor.handle_rpc(req).await?;
95                serde_json::to_value(resp).map_err(|_| Error::new(ErrorCode::ParseError))
96            }
97            Method::AcceptAnswer => {
98                let req = serde_json::from_value::<AcceptAnswerRequest>(params)
99                    .map_err(|e| Error::invalid_params(e.to_string()))?;
100                let resp = processor.handle_rpc(req).await?;
101                serde_json::to_value(resp).map_err(|_| Error::new(ErrorCode::ParseError))
102            }
103            Method::Disconnect => {
104                let req = serde_json::from_value::<DisconnectRequest>(params)
105                    .map_err(|e| Error::invalid_params(e.to_string()))?;
106                let resp = processor.handle_rpc(req).await?;
107                serde_json::to_value(resp).map_err(|_| Error::new(ErrorCode::ParseError))
108            }
109            Method::SendBackendMessage => {
110                let req = serde_json::from_value::<SendBackendMessageRequest>(params)
111                    .map_err(|e| Error::invalid_params(e.to_string()))?;
112                let resp = processor.handle_rpc(req).await?;
113                serde_json::to_value(resp).map_err(|_| Error::new(ErrorCode::ParseError))
114            }
115            Method::SendE2eHandshake => {
116                let req = serde_json::from_value::<SendE2eHandshakeRequest>(params)
117                    .map_err(|e| Error::invalid_params(e.to_string()))?;
118                let resp = processor.handle_rpc(req).await?;
119                serde_json::to_value(resp).map_err(|_| Error::new(ErrorCode::ParseError))
120            }
121            Method::SendE2eMessage => {
122                let req = serde_json::from_value::<SendE2eMessageRequest>(params)
123                    .map_err(|e| Error::invalid_params(e.to_string()))?;
124                let resp = processor.handle_rpc(req).await?;
125                serde_json::to_value(resp).map_err(|_| Error::new(ErrorCode::ParseError))
126            }
127            Method::PublishMessageToTopic => {
128                let req = serde_json::from_value::<PublishMessageToTopicRequest>(params)
129                    .map_err(|e| Error::invalid_params(e.to_string()))?;
130                let resp = processor.handle_rpc(req).await?;
131                serde_json::to_value(resp).map_err(|_| Error::new(ErrorCode::ParseError))
132            }
133            Method::FetchTopicMessages => {
134                let req = serde_json::from_value::<FetchTopicMessagesRequest>(params)
135                    .map_err(|e| Error::invalid_params(e.to_string()))?;
136                let resp = processor.handle_rpc(req).await?;
137                serde_json::to_value(resp).map_err(|_| Error::new(ErrorCode::ParseError))
138            }
139            Method::RegisterService => {
140                let req = serde_json::from_value::<RegisterServiceRequest>(params)
141                    .map_err(|e| Error::invalid_params(e.to_string()))?;
142                let resp = processor.handle_rpc(req).await?;
143                serde_json::to_value(resp).map_err(|_| Error::new(ErrorCode::ParseError))
144            }
145            Method::LookupService => {
146                let req = serde_json::from_value::<LookupServiceRequest>(params)
147                    .map_err(|e| Error::invalid_params(e.to_string()))?;
148                let resp = processor.handle_rpc(req).await?;
149                serde_json::to_value(resp).map_err(|_| Error::new(ErrorCode::ParseError))
150            }
151            Method::NodeInfo => {
152                let req = serde_json::from_value::<NodeInfoRequest>(params)
153                    .map_err(|e| Error::invalid_params(e.to_string()))?;
154                let resp = processor.handle_rpc(req).await?;
155                serde_json::to_value(resp).map_err(|_| Error::new(ErrorCode::ParseError))
156            }
157            Method::NodeDid => {
158                let req = serde_json::from_value::<NodeDidRequest>(params)
159                    .map_err(|e| Error::invalid_params(e.to_string()))?;
160                let resp = processor.handle_rpc(req).await?;
161                serde_json::to_value(resp).map_err(|_| Error::new(ErrorCode::ParseError))
162            }
163        }
164    }
165}
166
167impl ExternalRpcHandler {
168    /// Handle rpc request.
169    pub async fn handle_request<P>(
170        &self,
171        processor: Arc<P>,
172        method: String,
173        params: serde_json::Value,
174    ) -> Result<serde_json::Value>
175    where
176        P: HandleRpc<AnswerOfferRequest, AnswerOfferResponse>
177            + HandleRpc<NodeInfoRequest, NodeInfoResponse>
178            + HandleRpc<NodeDidRequest, NodeDidResponse>,
179    {
180        let method = Method::try_from(method.as_str()).map_err(|_| Error {
181            code: ErrorCode::MethodNotFound,
182            message: format!("method {method} is not found"),
183            data: None,
184        })?;
185
186        match method {
187            Method::AnswerOffer => {
188                let req = serde_json::from_value::<AnswerOfferRequest>(params)
189                    .map_err(|e| Error::invalid_params(e.to_string()))?;
190                let resp = processor.handle_rpc(req).await?;
191                serde_json::to_value(resp).map_err(|_| Error::new(ErrorCode::ParseError))
192            }
193            Method::NodeInfo => {
194                let req = serde_json::from_value::<NodeInfoRequest>(params)
195                    .map_err(|e| Error::invalid_params(e.to_string()))?;
196                let resp = processor.handle_rpc(req).await?;
197                serde_json::to_value(resp).map_err(|_| Error::new(ErrorCode::ParseError))
198            }
199            Method::NodeDid => {
200                let req = serde_json::from_value::<NodeDidRequest>(params)
201                    .map_err(|e| Error::invalid_params(e.to_string()))?;
202                let resp = processor.handle_rpc(req).await?;
203                serde_json::to_value(resp).map_err(|_| Error::new(ErrorCode::ParseError))
204            }
205            _ => Err(Error {
206                code: ErrorCode::InvalidRequest,
207                message: format!("method {} is not allowed", method.as_str()),
208                data: None,
209            }),
210        }
211    }
212}
rings_rpc/protos/rings_node_handler.rs

rings_rpc/protos/
rings_node_handler.rs
