Split RMain::setup() from RMain::start()

This way the former can be run in a background thread whereas the latter
can still run in the main thread and propagate panics

Author: lionel-

crates/ark/src/fixtures/dummy_frontend.rs

@@ -42,24 +42,25 @@ impl DummyArkFrontend {
         let frontend = DummyFrontend::new();
         let connection_file = frontend.get_connection_file();
 
+        // Start the kernel in this thread so that panics are propagated
+        crate::start::start_kernel(
+            connection_file,
+            vec![
+                String::from("--interactive"),
+                String::from("--vanilla"),
+                String::from("--no-save"),
+                String::from("--no-restore"),
+            ],
+            None,
+            SessionMode::Console,
+            false,
+        );
+
+        // Start the REPL in a background thread, does not return and is never joined
         stdext::spawn!("dummy_kernel", || {
-            crate::start::start_kernel(
-                connection_file,
-                vec![
-                    String::from("--interactive"),
-                    String::from("--vanilla"),
-                    String::from("--no-save"),
-                    String::from("--no-restore"),
-                ],
-                None,
-                SessionMode::Console,
-                false,
-            );
+            RMain::start();
         });
 
-        // Wait for startup to complete
-        RMain::wait_r_initialized();
-
         frontend.complete_initialization();
         frontend
     }

crates/ark/src/interface.rs

@@ -282,9 +282,14 @@ pub enum ConsoleResult {
 }
 
 impl RMain {
-    /// Starts the main R thread and initializes the `R_MAIN` singleton.
-    /// Doesn't return. Must be called only once.
-    pub fn start(
+    /// Sets up the main R thread and initializes the `R_MAIN` singleton. Must
+    /// be called only once. This is doing as much setup as possible before
+    /// starting the R REPL. Since the REPL does not return, it might be
+    /// launched in a background thread (which we do in integration tests). The
+    /// setup can still be done in your main thread so that panics may propagate
+    /// as expected. Call `RMain::start_repl()` after this to actually start the
+    /// R REPL.
+    pub fn setup(
         r_args: Vec<String>,
         startup_file: Option<String>,
         kernel_mutex: Arc<Mutex<Kernel>>,
@@ -423,8 +428,13 @@ impl RMain {
         if !ignore_user_r_profile {
             startup::source_user_r_profile();
         }
+    }
 
-        // Does not return!
+    /// Start the REPL. Does not return!
+    pub fn start() {
+        // Update the main thread ID in case the REPL is started in a background
+        // thread (e.g. in integration tests)
+        unsafe { R_MAIN_THREAD_ID = Some(std::thread::current().id()) };
         crate::sys::interface::run_r();
     }
 

crates/ark/src/main.rs

@@ -12,6 +12,7 @@ use std::env;
 
 use amalthea::connection_file::ConnectionFile;
 use amalthea::kernel_spec::KernelSpec;
+use ark::interface::RMain;
 use ark::interface::SessionMode;
 use ark::logger;
 use ark::signals::initialize_signal_block;
@@ -315,13 +316,18 @@ fn parse_file(
         Ok(connection) => {
             log::info!("Loaded connection information from frontend in {connection_file}");
             log::info!("Connection data: {:?}", connection);
+
+            // Set up R and start the Jupyter kernel
             start_kernel(
                 connection,
                 r_args,
                 startup_file,
                 session_mode,
                 capture_streams,
             );
+
+            // Start the REPL, does not return
+            RMain::start();
         },
         Err(error) => {
             log::error!("Couldn't read connection file {connection_file}: {error:?}");

crates/ark/src/start.rs

@@ -22,7 +22,8 @@ use crate::request::KernelRequest;
 use crate::request::RRequest;
 use crate::shell::Shell;
 
-/// Exported for unit tests. Does not return.
+/// Exported for unit tests.
+/// Call `RMain::start_repl()` after this.
 pub fn start_kernel(
     connection_file: ConnectionFile,
     r_args: Vec<String>,
@@ -112,8 +113,8 @@ pub fn start_kernel(
         panic!("Couldn't connect to frontend: {err:?}");
     }
 
-    // Start the R REPL (does not return for the duration of the session)
-    crate::interface::RMain::start(
+    // Setup the channels and R
+    crate::interface::RMain::setup(
         r_args,
         startup_file,
         kernel_clone,