diff options
Diffstat (limited to 'crates/server/src/dispatch.rs')
-rw-r--r-- | crates/server/src/dispatch.rs | 151 |
1 files changed, 0 insertions, 151 deletions
diff --git a/crates/server/src/dispatch.rs b/crates/server/src/dispatch.rs deleted file mode 100644 index 806534944..000000000 --- a/crates/server/src/dispatch.rs +++ /dev/null | |||
@@ -1,151 +0,0 @@ | |||
1 | use std::marker::PhantomData; | ||
2 | |||
3 | use serde::{ | ||
4 | ser::Serialize, | ||
5 | de::DeserializeOwned, | ||
6 | }; | ||
7 | use serde_json; | ||
8 | use drop_bomb::DropBomb; | ||
9 | |||
10 | use ::{ | ||
11 | Result, | ||
12 | req::{ClientRequest, Notification}, | ||
13 | io::{RawResponse, RawRequest, RawNotification}, | ||
14 | }; | ||
15 | |||
16 | pub struct Responder<R: ClientRequest> { | ||
17 | id: u64, | ||
18 | bomb: DropBomb, | ||
19 | ph: PhantomData<fn(R)>, | ||
20 | } | ||
21 | |||
22 | impl<R: ClientRequest> Responder<R> { | ||
23 | pub fn into_response(mut self, result: Result<R::Result>) -> Result<RawResponse> { | ||
24 | self.bomb.defuse(); | ||
25 | let res = match result { | ||
26 | Ok(result) => { | ||
27 | RawResponse { | ||
28 | id: self.id, | ||
29 | result: serde_json::to_value(result)?, | ||
30 | error: serde_json::Value::Null, | ||
31 | } | ||
32 | } | ||
33 | Err(e) => { | ||
34 | error_response( | ||
35 | self.id, | ||
36 | ErrorCode::InternalError, | ||
37 | format!("internal error: {}", e), | ||
38 | )? | ||
39 | } | ||
40 | }; | ||
41 | Ok(res) | ||
42 | } | ||
43 | } | ||
44 | |||
45 | fn parse_request_as<R: ClientRequest>(raw: RawRequest) | ||
46 | -> Result<::std::result::Result<(R::Params, Responder<R>), RawRequest>> | ||
47 | { | ||
48 | if raw.method != R::METHOD { | ||
49 | return Ok(Err(raw)); | ||
50 | } | ||
51 | |||
52 | let params: R::Params = serde_json::from_value(raw.params)?; | ||
53 | let responder = Responder { | ||
54 | id: raw.id, | ||
55 | bomb: DropBomb::new("dropped request"), | ||
56 | ph: PhantomData, | ||
57 | }; | ||
58 | Ok(Ok((params, responder))) | ||
59 | } | ||
60 | |||
61 | pub fn handle_request<R, F>(req: RawRequest, f: F) -> Result<::std::result::Result<u64, RawRequest>> | ||
62 | where | ||
63 | R: ClientRequest, | ||
64 | F: FnOnce(R::Params, Responder<R>) -> Result<()> | ||
65 | { | ||
66 | let id = req.id; | ||
67 | match parse_request_as::<R>(req)? { | ||
68 | Ok((params, responder)) => { | ||
69 | let () = f(params, responder)?; | ||
70 | Ok(Ok(id)) | ||
71 | }, | ||
72 | Err(r) => Ok(Err(r)), | ||
73 | } | ||
74 | } | ||
75 | |||
76 | fn parse_notification_as<N>(raw: RawNotification) -> Result<::std::result::Result<N::Params, RawNotification>> | ||
77 | where | ||
78 | N: Notification, | ||
79 | N::Params: DeserializeOwned, | ||
80 | { | ||
81 | if raw.method != N::METHOD { | ||
82 | return Ok(Err(raw)); | ||
83 | } | ||
84 | let params: N::Params = serde_json::from_value(raw.params)?; | ||
85 | Ok(Ok(params)) | ||
86 | } | ||
87 | |||
88 | pub fn handle_notification<N, F>(not: &mut Option<RawNotification>, f: F) -> Result<()> | ||
89 | where | ||
90 | N: Notification, | ||
91 | N::Params: DeserializeOwned, | ||
92 | F: FnOnce(N::Params) -> Result<()> | ||
93 | { | ||
94 | match not.take() { | ||
95 | None => Ok(()), | ||
96 | Some(n) => match parse_notification_as::<N>(n)? { | ||
97 | Ok(params) => f(params), | ||
98 | Err(n) => { | ||
99 | *not = Some(n); | ||
100 | Ok(()) | ||
101 | } | ||
102 | } | ||
103 | } | ||
104 | } | ||
105 | |||
106 | pub fn send_notification<N>(params: N::Params) -> RawNotification | ||
107 | where | ||
108 | N: Notification, | ||
109 | N::Params: Serialize | ||
110 | { | ||
111 | RawNotification { | ||
112 | method: N::METHOD.to_string(), | ||
113 | params: serde_json::to_value(params) | ||
114 | .unwrap(), | ||
115 | } | ||
116 | } | ||
117 | |||
118 | pub fn unknown_method(id: u64) -> Result<RawResponse> { | ||
119 | error_response(id, ErrorCode::MethodNotFound, "unknown method") | ||
120 | } | ||
121 | |||
122 | fn error_response(id: u64, code: ErrorCode, message: impl Into<String>) -> Result<RawResponse> { | ||
123 | #[derive(Serialize)] | ||
124 | struct Error { | ||
125 | code: i32, | ||
126 | message: String, | ||
127 | } | ||
128 | let resp = RawResponse { | ||
129 | id, | ||
130 | result: serde_json::Value::Null, | ||
131 | error: serde_json::to_value(Error { | ||
132 | code: code as i32, | ||
133 | message: message.into(), | ||
134 | })?, | ||
135 | }; | ||
136 | Ok(resp) | ||
137 | } | ||
138 | |||
139 | #[allow(unused)] | ||
140 | enum ErrorCode { | ||
141 | ParseError = -32700, | ||
142 | InvalidRequest = -32600, | ||
143 | MethodNotFound = -32601, | ||
144 | InvalidParams = -32602, | ||
145 | InternalError = -32603, | ||
146 | ServerErrorStart = -32099, | ||
147 | ServerErrorEnd = -32000, | ||
148 | ServerNotInitialized = -32002, | ||
149 | UnknownErrorCode = -32001, | ||
150 | RequestCancelled = -32800, | ||
151 | } | ||