use crate::{ transport::{Event, Payload, Request, Response, Transport}, Result, }; use log::{error, info}; use serde::{Deserialize, Serialize}; use serde_json::{from_value, to_value, Value}; use std::sync::{ atomic::{AtomicU64, Ordering}, Arc, }; use std::{collections::HashMap, process::Stdio}; use tokio::{ io::{AsyncBufRead, AsyncWrite, BufReader, BufWriter}, net::TcpStream, process::{Child, Command}, sync::{ mpsc::{channel, Receiver, Sender, UnboundedReceiver, UnboundedSender}, Mutex, }, }; #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] pub struct DebuggerCapabilities { pub supports_configuration_done_request: Option, pub supports_function_breakpoints: Option, pub supports_conditional_breakpoints: Option, pub supports_exception_info_request: Option, pub support_terminate_debuggee: Option, pub supports_delayed_stack_trace_loading: Option, // TODO: complete this } #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] struct InitializeArguments { #[serde(rename = "clientID")] client_id: Option, client_name: Option, #[serde(rename = "adapterID")] adapter_id: String, locale: Option, #[serde(rename = "linesStartAt1")] lines_start_at_one: Option, #[serde(rename = "columnsStartAt1")] columns_start_at_one: Option, path_format: Option, supports_variable_type: Option, supports_variable_paging: Option, supports_run_in_terminal_request: Option, supports_memory_references: Option, supports_progress_reporting: Option, supports_invalidated_event: Option, } #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] pub struct Checksum { pub algorithm: String, pub checksum: String, } #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] pub struct Source { pub name: Option, pub path: Option, pub source_reference: Option, pub presentation_hint: Option, pub origin: Option, pub sources: Option>, pub adapter_data: Option, pub checksums: Option>, } #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] pub struct SourceBreakpoint { pub line: usize, pub column: Option, pub condition: Option, pub hit_condition: Option, pub log_message: Option, } #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] struct SetBreakpointsArguments { source: Source, breakpoints: Option>, // lines is deprecated source_modified: Option, } #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] pub struct Breakpoint { pub id: Option, pub verified: bool, pub message: Option, pub source: Option, pub line: Option, pub column: Option, pub end_line: Option, pub end_column: Option, pub instruction_reference: Option, pub offset: Option, } #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] struct SetBreakpointsResponseBody { breakpoints: Option>, } #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] struct ContinueArguments { thread_id: usize, } #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] struct ContinueResponseBody { all_threads_continued: Option, } #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] struct StackFrameFormat { parameters: Option, parameter_types: Option, parameter_names: Option, parameter_values: Option, line: Option, module: Option, include_all: Option, } #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] struct StackTraceArguments { thread_id: usize, start_frame: Option, levels: Option, format: Option, } #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] pub struct StackFrame { pub id: usize, pub name: String, pub source: Option, pub line: usize, pub column: usize, pub end_line: Option, pub end_column: Option, pub can_restart: Option, pub instruction_pointer_reference: Option, pub module_id: Option, pub presentation_hint: Option, } #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] struct StackTraceResponseBody { total_frames: Option, stack_frames: Vec, } #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] pub struct Thread { pub id: usize, pub name: String, } #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] struct ThreadsResponseBody { threads: Vec, } #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] struct ScopesArguments { frame_id: usize, } #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] pub struct Scope { pub name: String, pub presentation_hint: Option, pub variables_reference: usize, pub named_variables: Option, pub indexed_variables: Option, pub expensive: bool, pub source: Option, pub line: Option, pub column: Option, pub end_line: Option, pub end_column: Option, } #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] struct ScopesResponseBody { scopes: Vec, } #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] struct ValueFormat { hex: Option, } #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] struct VariablesArguments { variables_reference: usize, filter: Option, start: Option, count: Option, format: Option, } #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] pub struct VariablePresentationHint { pub kind: Option, pub attributes: Option>, pub visibility: Option, } #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] pub struct Variable { pub name: String, pub value: String, #[serde(rename = "type")] pub data_type: Option, pub presentation_hint: Option, pub evaluate_name: Option, pub variables_reference: usize, pub named_variables: Option, pub indexed_variables: Option, pub memory_reference: Option, } #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] struct VariablesResponseBody { variables: Vec, } #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] pub struct OutputEventBody { pub output: String, pub category: Option, pub group: Option, pub line: Option, pub column: Option, pub variables_reference: Option, pub source: Option, pub data: Option, } #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] pub struct StoppedEventBody { pub reason: String, pub description: Option, pub thread_id: Option, pub preserve_focus_hint: Option, pub text: Option, pub all_threads_stopped: Option, pub hit_breakpoint_ids: Option>, } #[derive(Debug)] pub struct Client { id: usize, _process: Option, server_tx: UnboundedSender, request_counter: AtomicU64, capabilities: Option, awaited_events: Arc>>>, } impl Client { pub fn streams( rx: Box, tx: Box, id: usize, process: Option, ) -> Result { let (server_rx, server_tx) = Transport::start(rx, tx, id); let client = Self { id, _process: process, server_tx, request_counter: AtomicU64::new(0), capabilities: None, awaited_events: Arc::new(Mutex::new(HashMap::default())), }; tokio::spawn(Self::recv(Arc::clone(&client.awaited_events), server_rx)); Ok(client) } async fn recv( awaited_events: Arc>>>, mut server_rx: UnboundedReceiver, ) { while let Some(msg) = server_rx.recv().await { match msg { Payload::Event(ev) => { let name = ev.event.clone(); let hashmap = awaited_events.lock().await; let tx = hashmap.get(&name); match tx { Some(tx) => match tx.send(ev).await { Ok(_) => (), Err(_) => error!( "Tried sending event into a closed channel (name={:?})", name ), }, None => { info!("unhandled event"); // client_tx.send(Payload::Event(ev)).expect("Failed to send"); } } } Payload::Response(_) => unreachable!(), Payload::Request(_) => todo!(), } } } pub async fn listen_for_event(&self, name: String) -> Receiver { let (rx, tx) = channel(1); self.awaited_events.lock().await.insert(name.clone(), rx); tx } pub async fn tcp(addr: std::net::SocketAddr, id: usize) -> Result { let stream = TcpStream::connect(addr).await?; let (rx, tx) = stream.into_split(); Self::streams(Box::new(BufReader::new(rx)), Box::new(tx), id, None) } pub fn stdio(cmd: &str, args: Vec<&str>, id: usize) -> Result { let process = Command::new(cmd) .args(args) .stdin(Stdio::piped()) .stdout(Stdio::piped()) // make sure the process is reaped on drop .kill_on_drop(true) .spawn(); let mut process = process?; // TODO: do we need bufreader/writer here? or do we use async wrappers on unblock? let writer = BufWriter::new(process.stdin.take().expect("Failed to open stdin")); let reader = BufReader::new(process.stdout.take().expect("Failed to open stdout")); Self::streams( Box::new(BufReader::new(reader)), Box::new(writer), id, Some(process), ) } pub fn id(&self) -> usize { self.id } fn next_request_id(&self) -> u64 { self.request_counter.fetch_add(1, Ordering::Relaxed) } async fn request(&self, command: String, arguments: Option) -> Result { let (callback_rx, mut callback_tx) = channel(1); let req = Request { back_ch: Some(callback_rx), seq: self.next_request_id(), msg_type: "request".to_owned(), command, arguments, }; self.server_tx .send(req) .expect("Failed to send request to debugger"); callback_tx .recv() .await .expect("Failed to receive response") } pub fn capabilities(&self) -> &DebuggerCapabilities { self.capabilities .as_ref() .expect("language server not yet initialized!") } pub async fn initialize(&mut self, adapter_id: String) -> Result<()> { let args = InitializeArguments { client_id: Some("hx".to_owned()), client_name: Some("helix".to_owned()), adapter_id, locale: Some("en-us".to_owned()), lines_start_at_one: Some(true), columns_start_at_one: Some(true), path_format: Some("path".to_owned()), supports_variable_type: Some(false), supports_variable_paging: Some(false), supports_run_in_terminal_request: Some(false), supports_memory_references: Some(false), supports_progress_reporting: Some(false), supports_invalidated_event: Some(false), }; let response = self .request("initialize".to_owned(), to_value(args).ok()) .await?; self.capabilities = from_value(response.body.unwrap()).ok(); Ok(()) } pub async fn disconnect(&mut self) -> Result<()> { self.request("disconnect".to_owned(), None).await?; Ok(()) } pub async fn launch(&mut self, args: impl Serialize) -> Result<()> { let mut initialized = self.listen_for_event("initialized".to_owned()).await; self.request("launch".to_owned(), to_value(args).ok()) .await?; initialized.recv().await; Ok(()) } pub async fn attach(&mut self, args: impl Serialize) -> Result<()> { let mut initialized = self.listen_for_event("initialized".to_owned()).await; self.request("attach".to_owned(), to_value(args).ok()) .await?; initialized.recv().await; Ok(()) } pub async fn set_breakpoints( &mut self, file: String, breakpoints: Vec, ) -> Result>> { let args = SetBreakpointsArguments { source: Source { path: Some(file), name: None, source_reference: None, presentation_hint: None, origin: None, sources: None, adapter_data: None, checksums: None, }, breakpoints: Some(breakpoints), source_modified: Some(false), }; let response = self .request("setBreakpoints".to_owned(), to_value(args).ok()) .await?; let body: Option = from_value(response.body.unwrap()).ok(); Ok(body.map(|b| b.breakpoints).unwrap()) } pub async fn configuration_done(&mut self) -> Result<()> { self.request("configurationDone".to_owned(), None).await?; Ok(()) } pub async fn continue_thread(&mut self, thread_id: usize) -> Result> { let args = ContinueArguments { thread_id }; let response = self .request("continue".to_owned(), to_value(args).ok()) .await?; let body: Option = from_value(response.body.unwrap()).ok(); Ok(body.map(|b| b.all_threads_continued).unwrap()) } pub async fn stack_trace( &mut self, thread_id: usize, ) -> Result<(Vec, Option)> { let args = StackTraceArguments { thread_id, start_frame: None, levels: None, format: None, }; let response = self .request("stackTrace".to_owned(), to_value(args).ok()) .await?; let body: StackTraceResponseBody = from_value(response.body.unwrap()).unwrap(); Ok((body.stack_frames, body.total_frames)) } pub async fn threads(&mut self) -> Result> { let response = self.request("threads".to_owned(), None).await?; let body: ThreadsResponseBody = from_value(response.body.unwrap()).unwrap(); Ok(body.threads) } pub async fn scopes(&mut self, frame_id: usize) -> Result> { let args = ScopesArguments { frame_id }; let response = self .request("scopes".to_owned(), to_value(args).ok()) .await?; let body: ScopesResponseBody = from_value(response.body.unwrap()).unwrap(); Ok(body.scopes) } pub async fn variables(&mut self, variables_reference: usize) -> Result> { let args = VariablesArguments { variables_reference, filter: None, start: None, count: None, format: None, }; let response = self .request("variables".to_owned(), to_value(args).ok()) .await?; let body: VariablesResponseBody = from_value(response.body.unwrap()).unwrap(); Ok(body.variables) } }