debugger_message API for Python

vadimcn · vadimcn · commit f4cf282695fe · 2024-11-06T19:36:50.000-08:00
diff --git a/adapter/adapter-protocol/src/codelldb.rs b/adapter/adapter-protocol/src/codelldb.rs
@@ -115,8 +115,7 @@ pub enum RequestArguments {
     _symbols(SymbolsRequest),
     _excludeCaller(ExcludeCallerRequest),
     _setExcludedCallers(SetExcludedCallersRequest),
-    //_pythonMessage(Box<serde_json::value::RawValue>), https://github.com/serde-rs/json/issues/883
-    _pythonMessage(serde_json::value::Value),
+    _pythonMessage(serde_json::Value),
     #[serde(other)]
     unknown,
 }
@@ -188,7 +187,7 @@ pub enum EventBody {
     invalidated(InvalidatedEventBody),
     stopped(StoppedEventBody),
     // Custom
-    _pythonMessage(Box<serde_json::value::RawValue>),
+    _pythonMessage(serde_json::Value),
 }
 
 #[derive(Serialize, Deserialize, Debug, Copy, Clone)]
diff --git a/adapter/codelldb/src/debug_session.rs b/adapter/codelldb/src/debug_session.rs
@@ -14,6 +14,7 @@ use crate::fsutil::normalize_path;
 use crate::handles::{self, HandleTree};
 use crate::must_initialize::{Initialized, MustInitialize, NotInitialized};
 use crate::platform::{get_fs_path_case, make_case_folder, pipe};
+use crate::python::PythonEvent;
 use crate::python::{PythonInterface, PythonSession};
 use crate::shared::Shared;
 use crate::terminal::Terminal;
@@ -119,12 +120,12 @@ impl DebugSession {
 
         let (con_reader, con_writer) = pipe().unwrap();
 
-        let python = if let Some(python_interface) = python_interface {
+        let (python, mut python_events_stream) = if let Some(python_interface) = python_interface {
             let (python, python_events) = python_interface.new_session(&debugger, con_writer.try_clone().unwrap());
-            DebugSession::pipe_python_events(&dap_session, python_events);
-            Some(python)
+            (Some(python), python_events)
         } else {
-            None
+            let (_, receiver) = mpsc::channel(0);
+            (None, receiver)
         };
 
         let target = debugger.dummy_target();
@@ -194,6 +195,14 @@ impl DebugSession {
         local_set.spawn_local(async move {
             loop {
                 tokio::select! {
+                    // Python events
+                    Some(event) = python_events_stream.recv() => {
+                        shared_session.map(|s| s.handle_python_event(event)).await;
+                    }
+                    // LLDB events.
+                    Some(event) = debug_events_stream.recv() => {
+                        shared_session.map(|s| s.handle_debug_event(event)).await;
+                    }
                     // Requests from VSCode
                     request = requests_receiver.recv() => {
                         match request {
@@ -205,10 +214,6 @@ impl DebugSession {
                             }
                         }
                     }
-                    // LLDB events.
-                    Some(event) = debug_events_stream.recv() => {
-                        shared_session.map( |s| s.handle_debug_event(event)).await;
-                    }
                 }
             }
 
@@ -263,16 +268,6 @@ impl DebugSession {
         });
     }
 
-    // Pipe events from the Python interface to the DAP session.
-    fn pipe_python_events(dap_session: &DAPSession, mut python_events: mpsc::Receiver<EventBody>) {
-        let dap_session = dap_session.clone();
-        tokio::spawn(async move {
-            while let Some(event) = python_events.recv().await {
-                log_errors!(dap_session.send_event(event).await);
-            }
-        });
-    }
-
     /// Handle request cancellations.
     fn cancellation_filter(
         dap_session: &DAPSession,
@@ -1391,6 +1386,17 @@ impl DebugSession {
         Ok(())
     }
 
+    fn handle_python_event(&mut self, event: PythonEvent) {
+        match event {
+            PythonEvent::SendDapEvent(event) => {
+                log_errors!(self.dap_session.try_send_event(event));
+            }
+            PythonEvent::DebuggerMessage { output, category } => {
+                self.console_message_impl(Some(&category), output);
+            }
+        }
+    }
+
     fn handle_adapter_settings(&mut self, args: AdapterSettings) -> Result<(), Error> {
         let old_console_mode = self.console_mode;
         self.update_adapter_settings_and_caps(&args);
diff --git a/adapter/codelldb/src/python.rs b/adapter/codelldb/src/python.rs
@@ -3,6 +3,7 @@ use crate::prelude::*;
 use crate::must_initialize::{Initialized, MustInitialize};
 use adapter_protocol::{AdapterSettings, EventBody};
 use lldb::*;
+use serde_derive::*;
 
 use std::collections::HashMap;
 use std::ffi::CStr;
@@ -34,12 +35,19 @@ impl Drop for PyObject {
 
 unsafe impl Send for PyObject {}
 
+#[derive(Deserialize, Serialize, Debug, Clone)]
+#[serde(tag = "type")]
+pub enum PythonEvent {
+    DebuggerMessage { output: String, category: String },
+    SendDapEvent(EventBody),
+}
+
 // Interface through which the rest of CodeLLDB interacts with Python, via C ABI.
 // It is intended to be a singleton, since there is only one Python interpreter in LLDB process.
 pub struct PythonInterface {
     adapter_dir: PathBuf,
     py: MustInitialize<PythonCalls>,
-    session_event_senders: Mutex<HashMap<u64, mpsc::Sender<EventBody>>>,
+    session_event_senders: Mutex<HashMap<u64, mpsc::Sender<PythonEvent>>>,
 }
 
 struct PythonCalls {
@@ -102,11 +110,12 @@ pub fn initialize(debugger: &SBDebugger, adapter_dir: &Path) -> Result<Arc<Pytho
     unsafe extern "C" fn python_event_callback(
         interface: *mut PythonInterface,
         session_id: c_int,
-        body_json: *const c_char,
+        event: *const c_char,
     ) {
-        let body_json = CStr::from_ptr(body_json).to_str().unwrap().to_string();
-        let event = EventBody::_pythonMessage(serde_json::value::RawValue::from_string(body_json).unwrap());
-        (*interface).dispatch_python_event(session_id as u64, event);
+        match serde_json::from_slice::<PythonEvent>(CStr::from_ptr(event).to_bytes()) {
+            Ok(event) => (*interface).dispatch_python_event(session_id as u64, event),
+            Err(err) => error!("{}", err),
+        }
     }
 
     unsafe extern "C" fn init_callback(
@@ -170,7 +179,7 @@ impl PythonInterface {
         self: Arc<PythonInterface>,
         debugger: &SBDebugger,
         console_stream: std::fs::File,
-    ) -> (PythonSession, mpsc::Receiver<EventBody>) {
+    ) -> (PythonSession, mpsc::Receiver<PythonEvent>) {
         let (sender, receiver) = mpsc::channel(100);
         let session = PythonSession {
             interface: self.clone(),
@@ -189,8 +198,8 @@ impl PythonInterface {
         (session, receiver)
     }
 
-    // Send event generated by Python to DAP client
-    fn dispatch_python_event(&self, session_id: u64, event: EventBody) {
+    // Dispatch Python events to the appropriate DebugSession
+    fn dispatch_python_event(&self, session_id: u64, event: PythonEvent) {
         let senders = self.session_event_senders.lock().unwrap();
         if let Some(sender) = senders.get(&session_id) {
             log_errors!(sender.try_send(event));
@@ -381,3 +390,11 @@ fn evaluate() {
     let value = result.unwrap().value_as_signed(0);
     assert_eq!(value, 4);
 }
+
+#[test]
+fn serialization() {
+    serde_json::from_str::<PythonEvent>(
+        r#"{"type":"SendDapEvent", "event": "_pythonMessage", "body": {"foo": "bar"} }"#,
+    )
+    .unwrap();
+}
diff --git a/adapter/scripts/codelldb/__init__.py b/adapter/scripts/codelldb/__init__.py
@@ -1,4 +1,4 @@
-from .api import evaluate, wrap, unwrap, get_config, create_webview, display_html
+from .api import evaluate, wrap, unwrap, get_config, create_webview, display_html, debugger_message
 from .value import Value
 
 def __lldb_init_module(debugger, internal_dict):  # pyright: ignore
diff --git a/adapter/scripts/codelldb/api.py b/adapter/scripts/codelldb/api.py
@@ -43,15 +43,17 @@ def unwrap(obj: Value) -> lldb.SBValue:
 
 def create_webview(html: Optional[str] = None, title: Optional[str] = None, view_column: Optional[int] = None,
                    preserve_focus: bool = False, enable_find_widget: bool = False,
-                   retain_context_when_hidden: bool = False, enable_scripts: bool = False):
+                   retain_context_when_hidden: bool = False, enable_scripts: bool = False,
+                   preserve_orphaned: bool = False):
     '''Create a [webview panel](https://code.visualstudio.com/api/references/vscode-api#WebviewPanel).
         html:               HTML content to display in the webview.  May be later replaced via Webview.set_html().
         title:              Panel title.
         view_column:        Column in which to show the webview.
         preserve_focus:     Whether to preserve focus in the current editor when revealing the webview.
-        enable_find_widget: Controls if the find widget is enabled in the panel.
-        retain_context_when_hidden: Controls if the webview panel retains its context when it is hidden.
-        enable_scripts:     Controls if scripts are enabled in the webview.
+        enable_find_widget: Controls whether the find widget is enabled in the panel.
+        retain_context_when_hidden: Controls whether the webview panel retains its context when hidden.
+        enable_scripts:     Controls whether scripts are enabled in the webview.
+        preserve_orphaned:  Preserve webview panel after the end of the debug session.
     '''
     debugger_id = lldb.debugger.GetID()
     webview = Webview(debugger_id)
@@ -64,17 +66,24 @@ def create_webview(html: Optional[str] = None, title: Optional[str] = None, view
                                 preserveFocus=preserve_focus,
                                 enableFindWidget=enable_find_widget,
                                 retainContextWhenHidden=retain_context_when_hidden,
-                                enableScripts=enable_scripts
+                                enableScripts=enable_scripts,
+                                preserveOrphaned=preserve_orphaned,
                                 )
                            )
     return webview
 
 
-def display_html(html: str, title: Optional[str] = None, position: Optional[int] = None, reveal: bool = False):
+def debugger_message(output: str, category: str = 'console'):
+    interface.fire_event(lldb.debugger.GetID(), dict(type='DebuggerMessage', output=output, category=category))
+
+
+def display_html(html: str, title: Optional[str] = None, position: Optional[int] = None, reveal: bool = False,
+                 preserve_orphaned: bool = True):
     '''Display HTML content in a webview panel.
        display_html is **deprecated**, use create_webview instead.
     '''
-    global html_webview
+    inst_dict = interface.get_instance_dict(lldb.debugger)
+    html_webview = inst_dict.get('html_webview')
     if html_webview is None:
         warnings.warn("display_html is deprecated, use create_webview instead", DeprecationWarning)
 
@@ -83,27 +92,25 @@ def display_html(html: str, title: Optional[str] = None, position: Optional[int]
             title=title,
             view_column=position,
             preserve_focus=not reveal,
-            enable_scripts=True
+            enable_scripts=True,
+            preserve_orphaned=preserve_orphaned,
         )
 
         def on_message(message):
             if message['command'] == 'execute':
                 lldb.debugger.HandleCommand(message['text'])
 
         def on_disposed(message):
-            global html_webview
-            html_webview = None
+            del globals()['html_webview']
 
         html_webview.on_did_receive_message.add(on_message)
         html_webview.on_did_dispose.add(on_disposed)
+        inst_dict['html_webview'] = html_webview
     else:
         html_webview.set_html(html)
         if reveal:
             html_webview.reveal(view_column=position)
 
 
-html_webview = None
-
-
 def __lldb_init_module(debugger, internal_dict):  # pyright: ignore
     debugger.HandleCommand('command script add -c debugger.DebugInfoCommand debug_info')
diff --git a/adapter/scripts/codelldb/interface.py b/adapter/scripts/codelldb/interface.py
@@ -111,17 +111,22 @@ def PyResult(name, T):  # type: (str, type) -> type
 
 # ============================================================================================
 
-
+# Incoming messages from the DAP client
 on_did_receive_message = Event()
 
 
-def send_message(debugger_id, message):
+def send_message(debugger_id, message_body):
+    '''Send '_pythonMessage' event to the DAP client'''
+    fire_event(debugger_id, dict(type='SendDapEvent', event='_pythonMessage', body=message_body))
+
+
+def fire_event(debugger_id, event_body: object):
     log.error('interface has not been initialized yet')
 
 
 def initialize(init_callback_addr, callback_context, send_message_addr, log_level):
     '''One-time initialization of Rust-Python interface'''
-    global send_message
+    global fire_event
     logging.getLogger().setLevel(log_level)
 
     interrupt = ctypes.pythonapi.PyErr_SetInterrupt
@@ -139,12 +144,12 @@ def initialize(init_callback_addr, callback_context, send_message_addr, log_leve
     init_callback = CFUNCTYPE(None, c_void_p, POINTER(c_void_p), c_size_t)(init_callback_addr)
     init_callback(callback_context, ptr_arr, len(pointers))
 
-    send_message_raw = CFUNCTYPE(None, c_void_p, c_int, c_char_p)(send_message_addr)
+    fire_event_raw = CFUNCTYPE(None, c_void_p, c_int, c_char_p)(send_message_addr)
 
-    def _send_message(debugger_id, message):
-        return send_message_raw(callback_context, debugger_id, str_to_bytes(json.dumps(message)))
+    def _fire_event(debugger_id, event_body):
+        return fire_event_raw(callback_context, debugger_id, str_to_bytes(json.dumps(event_body)))
      # Override the global dummy function
-    send_message = _send_message
+    fire_event = _fire_event
 
 
 session_stdouts = {}
diff --git a/extension/webview.ts b/extension/webview.ts
@@ -3,8 +3,12 @@ import {
 } from "vscode";
 import { Dict } from './novsc/commonTypes';
 
+interface DebuggerPanel extends WebviewPanel {
+    preserveOrphaned: boolean
+}
+
 export class WebviewManager {
-    sessionPanels: Dict<Dict<WebviewPanel>> = {};
+    sessionPanels: Dict<Dict<DebuggerPanel>> = {};
 
     constructor(context: ExtensionContext) {
         let subscriptions = context.subscriptions;
@@ -17,7 +21,8 @@ export class WebviewManager {
             let panels = this.sessionPanels[session.id];
             if (panels) {
                 for (let panel of Object.values(panels)) {
-                    panel.dispose();
+                    if (!panel.preserveOrphaned)
+                        panel.dispose();
                 }
             }
         }
@@ -43,7 +48,7 @@ export class WebviewManager {
 
     createWebview(session: DebugSession, body: any) {
         let view_id = body.id;
-        let panel = window.createWebviewPanel(
+        let panel = <DebuggerPanel>window.createWebviewPanel(
             'codelldb.webview',
             body.title || session.name,
             {
@@ -65,6 +70,7 @@ export class WebviewManager {
         });
         if (body.html)
             panel.webview.html = body.html;
+        panel.preserveOrphaned = body.preserveOrphaned
 
         let panels = this.sessionPanels[session.id];
         if (panels == undefined) {

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-from .api import evaluate, wrap, unwrap, get_config, create_webview, display_html`
	`1`	`+from .api import evaluate, wrap, unwrap, get_config, create_webview, display_html, debugger_message`
`2`	`2`	`from .value import Value`
`3`	`3`
`4`	`4`	`def __lldb_init_module(debugger, internal_dict): # pyright: ignore`