Support stdio stream mode

Author: jm-observer

adapter/codelldb/src/lib.rs

@@ -31,6 +31,7 @@ mod must_initialize;
 mod platform;
 mod python;
 mod shared;
+mod stdio_stream;
 mod terminal;
 
 pub fn debug_server(matches: &ArgMatches) -> Result<(), Error> {
@@ -63,46 +64,52 @@ pub fn debug_server(matches: &ArgMatches) -> Result<(), Error> {
         debugger.command_interpreter().handle_command(&command, &mut command_result, false);
     }
 
-    let (port, connect) = if let Some(port) = matches.value_of("connect") {
-        (port.parse()?, true)
+    let (use_stdio, port, connect) = if let Some(port) = matches.value_of("connect") {
+        (false, port.parse()?, true)
     } else if let Some(port) = matches.value_of("port") {
-        (port.parse()?, false)
+        (false, port.parse()?, false)
     } else {
-        return Err("Either --connect or --port must be specified".into());
+        (true, 0, false)
     };
     let multi_session = matches.is_present("multi-session");
     let auth_token = matches.value_of("auth-token");
 
-    let localhost = net::Ipv4Addr::new(127, 0, 0, 1);
-    let addr = net::SocketAddr::new(localhost.into(), port);
-
     let rt = tokio::runtime::Builder::new_multi_thread() //
         .worker_threads(2)
         .enable_all()
         .build()
         .unwrap();
 
     rt.block_on(async {
-        if connect {
-            debug!("Connecting to {}", addr);
-            let mut tcp_stream = TcpStream::connect(addr).await?;
-            tcp_stream.set_nodelay(true).unwrap();
-            if let Some(auth_token) = auth_token {
-                let auth_header = format!("Auth-Token: {}\r\n", auth_token);
-                tcp_stream.write_all(&auth_header.as_bytes()).await?;
-            }
-            let framed_stream = dap_codec::DAPCodec::new().framed(tcp_stream);
+        if use_stdio {
+            debug!("Starting on stdio");
+            let stream = stdio_stream::StdioStream::new();
+            let framed_stream = dap_codec::DAPCodec::new().framed(stream);
             run_debug_session(Box::new(framed_stream), adapter_settings.clone()).await;
         } else {
-            let listener = TcpListener::bind(&addr).await?;
-            while {
-                debug!("Listening on {}", listener.local_addr()?);
-                let (tcp_stream, _) = listener.accept().await?;
+            let localhost = net::Ipv4Addr::new(127, 0, 0, 1);
+            let addr = net::SocketAddr::new(localhost.into(), port);
+            if connect {
+                debug!("Connecting to {}", addr);
+                let mut tcp_stream = TcpStream::connect(addr).await?;
                 tcp_stream.set_nodelay(true).unwrap();
+                if let Some(auth_token) = auth_token {
+                    let auth_header = format!("Auth-Token: {}\r\n", auth_token);
+                    tcp_stream.write_all(&auth_header.as_bytes()).await?;
+                }
                 let framed_stream = dap_codec::DAPCodec::new().framed(tcp_stream);
                 run_debug_session(Box::new(framed_stream), adapter_settings.clone()).await;
-                multi_session
-            } {}
+            } else {
+                let listener = TcpListener::bind(&addr).await?;
+                while {
+                    debug!("Listening on {}", listener.local_addr()?);
+                    let (tcp_stream, _) = listener.accept().await?;
+                    tcp_stream.set_nodelay(true).unwrap();
+                    let framed_stream = dap_codec::DAPCodec::new().framed(tcp_stream);
+                    run_debug_session(Box::new(framed_stream), adapter_settings.clone()).await;
+                    multi_session
+                } {}
+            }
         }
         Ok::<(), Error>(())
     })

adapter/codelldb/src/stdio_stream.rs

@@ -0,0 +1,37 @@
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
+
+pub struct StdioStream {
+    std_in: tokio::io::Stdin,
+    std_out: tokio::io::Stdout,
+}
+
+impl AsyncRead for StdioStream {
+    fn poll_read(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>) -> Poll<std::io::Result<()>> {
+        Pin::new(&mut self.get_mut().std_in).poll_read(cx, buf)
+    }
+}
+
+impl AsyncWrite for StdioStream {
+    fn poll_write(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8]) -> Poll<Result<usize, std::io::Error>> {
+        Pin::new(&mut self.get_mut().std_out).poll_write(cx, buf)
+    }
+
+    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), std::io::Error>> {
+        Pin::new(&mut self.get_mut().std_out).poll_flush(cx)
+    }
+
+    fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), std::io::Error>> {
+        Pin::new(&mut self.get_mut().std_out).poll_shutdown(cx)
+    }
+}
+
+impl StdioStream {
+    pub fn new() -> Self {
+        StdioStream {
+            std_in: tokio::io::stdin(),
+            std_out: tokio::io::stdout(),
+        }
+    }
+}

adapter/codelldb/src/terminal.rs

@@ -98,8 +98,8 @@ impl Terminal {
     pub fn attach_console(&self) {
         unsafe {
             let pid = self.data.parse::<u32>().unwrap();
-            dbg!(winapi::um::wincon::FreeConsole());
-            dbg!(winapi::um::wincon::AttachConsole(pid));
+            winapi::um::wincon::FreeConsole();
+            winapi::um::wincon::AttachConsole(pid);
         }
     }