git.iko.soy/helix
on master help sign in
refactor server message handling
9678df1Dmitry Sharshakov
helix-dap/src/transport.rs+44−46
compare with master
unifiedsplit
@@ -167,36 +167,51 @@ impl Transport {
167 client_tx: &UnboundedSender<Payload>,
167 client_tx: &UnboundedSender<Payload>,
168 msg: Payload,
168 msg: Payload,
169 ) -> Result<()> {
169 ) -> Result<()> {
170− let (id, result) = match msg {
170+ match msg {
171 Payload::Response(Response {
171 Payload::Response(Response {
172− success: true,
172+ ref success,
173− seq,
173+ ref seq,
174− request_seq,
175− ..
176− }) => {
177− info!("<- DAP success ({}, in response to {})", seq, request_seq);
178− if let Payload::Response(val) = msg {
179− (request_seq, Ok(val))
180− } else {
181− unreachable!();
182− }
183− }
184− Payload::Response(Response {
185− success: false,
186− message,
187− body,
188 request_seq,
174 request_seq,
189− command,
175+ ref command,
176+ ref message,
177+ ref body,
190 ..
178 ..
191 }) => {
179 }) => {
192− error!(
180+ let result = match success {
181+ true => {
182+ info!("<- DAP success ({}, in response to {})", seq, request_seq);
183+ if let Payload::Response(val) = msg {
184+ Ok(val)
185+ } else {
186+ unreachable!();
187+ }
188+ }
189+ false => {
190+ error!(
193− "<- DAP error {:?} ({:?}) for command #{} {}",
191+ "<- DAP error {:?} ({:?}) for command #{} {}",
194− message, body, request_seq, command
192+ message, body, request_seq, command
195− );
193+ );
196− (
194+
197− request_seq,
198− Err(Error::Other(anyhow::format_err!("{:?}", body))),
195+ Err(Error::Other(anyhow::format_err!("{:?}", body)))
199− )
196+ }
197+ };
198+
199+ let tx = self
200+ .pending_requests
201+ .lock()
202+ .await
203+ .remove(&request_seq)
204+ .expect("pending_request with id not found!");
205+
206+ match tx.send(result).await {
207+ Ok(_) => (),
208+ Err(_) => error!(
209+ "Tried sending response into a closed channel (id={:?}), original request likely timed out",
210+ request_seq
211+ ),
212+ };
213+
214+ Ok(())
200 }
215 }
201 Payload::Request(Request {
216 Payload::Request(Request {
202 ref command,
217 ref command,
@@ -205,33 +220,16 @@ impl Transport {
205 }) => {
220 }) => {
206 info!("<- DAP request {} #{}", command, seq);
221 info!("<- DAP request {} #{}", command, seq);
207 client_tx.send(msg).expect("Failed to send");
222 client_tx.send(msg).expect("Failed to send");
208− return Ok(());
223+ Ok(())
209 }
224 }
210 Payload::Event(Event {
225 Payload::Event(Event {
211 ref event, ref seq, ..
226 ref event, ref seq, ..
212 }) => {
227 }) => {
213 info!("<- DAP event {} #{}", event, seq);
228 info!("<- DAP event {} #{}", event, seq);
214 client_tx.send(msg).expect("Failed to send");
229 client_tx.send(msg).expect("Failed to send");
215− return Ok(());
230+ Ok(())
216 }
231 }
217− };
232+ }
218−
219− let tx = self
220− .pending_requests
221− .lock()
222− .await
223− .remove(&id)
224− .expect("pending_request with id not found!");
225−
226− match tx.send(result).await {
227− Ok(_) => (),
228− Err(_) => error!(
229− "Tried sending response into a closed channel (id={:?}), original request likely timed out",
230− id
231− ),
232− };
233−
234− Ok(())
235 }
233 }
236
234
237 async fn recv(
235 async fn recv(