dap: Add RunInTerminal reverse request, support replying to requests

pull/574/head
Blaž Hrastnik 3 years ago
parent bcf70d8e67
commit 5545f8ebb5

@ -1,5 +1,5 @@
use crate::{
transport::{Payload, Request, Transport},
transport::{Payload, Request, Response, Transport},
types::*,
Error, Result, ThreadId,
};
@ -29,7 +29,7 @@ use tokio::{
pub struct Client {
id: usize,
_process: Option<Child>,
server_tx: UnboundedSender<Request>,
server_tx: UnboundedSender<Payload>,
request_counter: AtomicU64,
pub caps: Option<DebuggerCapabilities>,
// thread_id -> frames
@ -234,7 +234,9 @@ impl Client {
arguments,
};
server_tx.send(req).map_err(|e| Error::Other(e.into()))?;
server_tx
.send(Payload::Request(req))
.map_err(|e| Error::Other(e.into()))?;
// TODO: specifiable timeout, delay other calls until initialize success
timeout(Duration::from_secs(20), callback_rx.recv())
@ -257,6 +259,40 @@ impl Client {
Ok(response)
}
pub fn reply(
&self,
request_seq: u64,
command: String,
result: core::result::Result<Value, Error>,
) -> impl Future<Output = Result<()>> {
let server_tx = self.server_tx.clone();
async move {
let response = match result {
Ok(result) => Response {
request_seq,
command,
success: true,
message: None,
body: Some(result),
},
Err(error) => Response {
request_seq,
command,
success: false,
message: Some(error.to_string()),
body: None,
},
};
server_tx
.send(Payload::Response(response))
.map_err(|e| Error::Other(e.into()))?;
Ok(())
}
}
pub fn capabilities(&self) -> &DebuggerCapabilities {
self.caps.as_ref().expect("debugger not yet initialized!")
}

@ -55,7 +55,7 @@ impl Transport {
server_stdin: Box<dyn AsyncWrite + Unpin + Send>,
server_stderr: Option<Box<dyn AsyncBufRead + Unpin + Send>>,
id: usize,
) -> (UnboundedReceiver<Payload>, UnboundedSender<Request>) {
) -> (UnboundedReceiver<Payload>, UnboundedSender<Payload>) {
let (client_tx, rx) = unbounded_channel();
let (tx, client_rx) = unbounded_channel();
@ -140,14 +140,14 @@ impl Transport {
async fn send_payload_to_server(
&self,
server_stdin: &mut Box<dyn AsyncWrite + Unpin + Send>,
mut req: Request,
mut payload: Payload,
) -> Result<()> {
let back_ch = req.back_ch.take();
let seq = req.seq;
let json = serde_json::to_string(&Payload::Request(req))?;
if let Some(back) = back_ch {
self.pending_requests.lock().await.insert(seq, back);
if let Payload::Request(request) = &mut payload {
if let Some(back) = request.back_ch.take() {
self.pending_requests.lock().await.insert(request.seq, back);
}
}
let json = serde_json::to_string(&payload)?;
self.send_string_to_server(server_stdin, json).await
}
@ -254,11 +254,11 @@ impl Transport {
async fn send(
transport: Arc<Self>,
mut server_stdin: Box<dyn AsyncWrite + Unpin + Send>,
mut client_rx: UnboundedReceiver<Request>,
mut client_rx: UnboundedReceiver<Payload>,
) {
while let Some(req) = client_rx.recv().await {
while let Some(payload) = client_rx.recv().await {
transport
.send_payload_to_server(&mut server_stdin, req)
.send_payload_to_server(&mut server_stdin, payload)
.await
.unwrap()
}

@ -1,5 +1,6 @@
use serde::{Deserialize, Serialize};
use serde_json::Value;
use std::collections::HashMap;
use std::path::PathBuf;
#[derive(
@ -541,6 +542,34 @@ pub mod requests {
type Result = SetExceptionBreakpointsResponse;
const COMMAND: &'static str = "setExceptionBreakpoints";
}
// Reverse Requests
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RunInTerminalResponse {
pub process_id: Option<usize>,
pub shell_process_id: Option<usize>,
}
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RunInTerminalArguments {
pub kind: Option<String>,
pub title: Option<String>,
pub cwd: String,
pub args: Vec<String>,
pub env: Option<HashMap<String, Option<String>>>,
}
#[derive(Debug)]
pub enum RunInTerminal {}
impl Request for RunInTerminal {
type Arguments = RunInTerminalArguments;
type Result = RunInTerminalResponse;
const COMMAND: &'static str = "runInTerminal";
}
}
// Events

@ -1,5 +1,5 @@
use helix_core::{merge_toml_values, syntax};
use helix_dap::Payload;
use helix_dap::{self as dap, Payload, Request};
use helix_lsp::{lsp, util::lsp_pos_to_pos, LspProgressMap};
use helix_view::{editor::Breakpoint, theme, Editor};
@ -468,7 +468,16 @@ impl Application {
}
}
Payload::Response(_) => unreachable!(),
Payload::Request(request) => unimplemented!("{:?}", request),
Payload::Request(request) => match request.command.as_str() {
dap::requests::RunInTerminal::COMMAND => {
let arguments: dap::requests::RunInTerminalArguments =
serde_json::from_value(request.arguments.unwrap_or_default()).unwrap();
// TODO: no unwrap
// TODO: dap reply
}
_ => log::error!("DAP reverse request not implemented: {:?}", request),
},
}
self.render();
}

Loading…
Cancel
Save