Fix ctrl-c handling (#2200)

Author: coolreader18

Cargo.lock

@@ -261,6 +261,7 @@ uuid = { version = "1.2.1", features = ["v4"] }
 walkdir = "2.2.5"
 wasmbin = "0.6"
 webbrowser = "1.0.2"
+windows-sys = "0.59"
 xdg = "2.5"
 
 # Vendor the openssl we rely on, rather than depend on a

Cargo.toml

@@ -69,6 +69,9 @@ wasmbin.workspace = true
 wasmtime.workspace = true
 webbrowser.workspace = true
 
+[target.'cfg(windows)'.dependencies]
+windows-sys = { workspace = true, features = ["Win32_System_Console"] }
+
 [dev-dependencies]
 insta.workspace = true
 fs-err.workspace = true

crates/cli/Cargo.toml

@@ -4,7 +4,6 @@ mod config;
 pub(crate) mod detect;
 mod edit_distance;
 mod errors;
-mod start;
 mod subcommands;
 mod tasks;
 pub mod util;

crates/cli/src/lib.rs

@@ -14,6 +14,7 @@ pub mod publish;
 pub mod repl;
 pub mod server;
 pub mod sql;
+pub mod start;
 pub mod subscribe;
 pub mod upgrade;
 pub mod version;

crates/cli/src/start.rs

@@ -0,0 +1,108 @@
+use std::ffi::OsString;
+use std::io;
+use std::process::{Command, ExitCode};
+
+use anyhow::Context;
+use clap::{Arg, ArgMatches};
+use spacetimedb_paths::SpacetimePaths;
+
+pub fn cli() -> clap::Command {
+    clap::Command::new("start")
+        .about("Start a local SpacetimeDB instance")
+        .long_about(
+            "\
+Start a local SpacetimeDB instance
+
+Run `spacetime start --help` to see all options.",
+        )
+        .disable_help_flag(true)
+        .arg(
+            Arg::new("edition")
+                .long("edition")
+                .help("The edition of SpacetimeDB to start up")
+                .value_parser(clap::value_parser!(Edition))
+                .default_value("standalone"),
+        )
+        .arg(
+            Arg::new("args")
+                .help("The args to pass to `spacetimedb-{edition} start`")
+                .value_parser(clap::value_parser!(OsString))
+                .allow_hyphen_values(true)
+                .num_args(0..),
+        )
+}
+
+#[derive(clap::ValueEnum, Clone, Copy)]
+enum Edition {
+    Standalone,
+    Cloud,
+}
+
+pub async fn exec(paths: &SpacetimePaths, args: &ArgMatches) -> anyhow::Result<ExitCode> {
+    let edition = args.get_one::<Edition>("edition").unwrap();
+    let args = args.get_many::<OsString>("args").unwrap_or_default();
+    let bin_name = match edition {
+        Edition::Standalone => "spacetimedb-standalone",
+        Edition::Cloud => "spacetimedb-cloud",
+    };
+    let resolved_exe = std::env::current_exe().context("could not retrieve current exe")?;
+    let bin_path = resolved_exe
+        .parent()
+        .unwrap()
+        .join(bin_name)
+        .with_extension(std::env::consts::EXE_EXTENSION);
+    let mut cmd = Command::new(&bin_path);
+    cmd.arg("start")
+        .arg("--data-dir")
+        .arg(&paths.data_dir)
+        .arg("--jwt-key-dir")
+        .arg(&paths.cli_config_dir)
+        .args(args);
+
+    exec_replace(&mut cmd).with_context(|| format!("exec failed for {}", bin_path.display()))
+}
+
+// implementation based on and docs taken verbatim from `cargo_util::ProcessBuilder::exec_replace`
+//
+/// Replaces the current process with the target process.
+///
+/// On Unix, this executes the process using the Unix syscall `execvp`, which will block
+/// this process, and will only return if there is an error.
+///
+/// On Windows this isn't technically possible. Instead we emulate it to the best of our
+/// ability. One aspect we fix here is that we specify a handler for the Ctrl-C handler.
+/// In doing so (and by effectively ignoring it) we should emulate proxying Ctrl-C
+/// handling to the application at hand, which will either terminate or handle it itself.
+/// According to Microsoft's documentation at
+/// <https://docs.microsoft.com/en-us/windows/console/ctrl-c-and-ctrl-break-signals>.
+/// the Ctrl-C signal is sent to all processes attached to a terminal, which should
+/// include our child process. If the child terminates then we'll reap them in Cargo
+/// pretty quickly, and if the child handles the signal then we won't terminate
+/// (and we shouldn't!) until the process itself later exits.
+fn exec_replace(cmd: &mut Command) -> io::Result<ExitCode> {
+    #[cfg(unix)]
+    {
+        use std::os::unix::process::CommandExt;
+        // if exec() succeeds, it diverges, so the function just returns an io::Error
+        let err = cmd.exec();
+        Err(err)
+    }
+    #[cfg(windows)]
+    {
+        use windows_sys::Win32::Foundation::{BOOL, FALSE, TRUE};
+        use windows_sys::Win32::System::Console::SetConsoleCtrlHandler;
+
+        unsafe extern "system" fn ctrlc_handler(_: u32) -> BOOL {
+            // Do nothing. Let the child process handle it.
+            TRUE
+        }
+        unsafe {
+            if SetConsoleCtrlHandler(Some(ctrlc_handler), TRUE) == FALSE {
+                return Err(io::Error::new(io::ErrorKind::Other, "Unable to set console handler"));
+            }
+        }
+
+        cmd.status()
+            .map(|status| ExitCode::from(status.code().unwrap_or(1).try_into().unwrap_or(1)))
+    }
+}

crates/cli/src/subcommands/mod.rs

@@ -11,3 +11,6 @@ anyhow.workspace = true
 clap.workspace = true
 semver.workspace = true
 tracing = { workspace = true, features = ["release_max_level_off"] }
+
+[target.'cfg(windows)'.dependencies]
+windows-sys = { workspace = true, features = ["Win32_System_Console"] }

crates/cli/src/subcommands/start.rs

@@ -2,6 +2,7 @@ use anyhow::Context;
 use spacetimedb_paths::{FromPathUnchecked, RootDir, SpacetimePaths};
 use std::ffi::OsStr;
 use std::ffi::OsString;
+use std::io;
 use std::path::PathBuf;
 use std::process::Command;
 use std::process::ExitCode;
@@ -34,15 +35,52 @@ pub(crate) fn run_cli(paths: &SpacetimePaths, argv0: Option<&OsStr>, args: Vec<O
         if let Some(argv0) = argv0 {
             cmd.arg0(argv0);
         }
+    }
+    exec_replace(&mut cmd).with_context(|| format!("exec failed for {}", cli_path.display()))
+}
+
+// implementation based on and docs taken verbatim from `cargo_util::ProcessBuilder::exec_replace`
+//
+/// Replaces the current process with the target process.
+///
+/// On Unix, this executes the process using the Unix syscall `execvp`, which will block
+/// this process, and will only return if there is an error.
+///
+/// On Windows this isn't technically possible. Instead we emulate it to the best of our
+/// ability. One aspect we fix here is that we specify a handler for the Ctrl-C handler.
+/// In doing so (and by effectively ignoring it) we should emulate proxying Ctrl-C
+/// handling to the application at hand, which will either terminate or handle it itself.
+/// According to Microsoft's documentation at
+/// <https://docs.microsoft.com/en-us/windows/console/ctrl-c-and-ctrl-break-signals>.
+/// the Ctrl-C signal is sent to all processes attached to a terminal, which should
+/// include our child process. If the child terminates then we'll reap them in Cargo
+/// pretty quickly, and if the child handles the signal then we won't terminate
+/// (and we shouldn't!) until the process itself later exits.
+fn exec_replace(cmd: &mut Command) -> io::Result<ExitCode> {
+    #[cfg(unix)]
+    {
+        use std::os::unix::process::CommandExt;
+        // if exec() succeeds, it diverges, so the function just returns an io::Error
         let err = cmd.exec();
-        Err(err).context(format!("exec failed for {}", cli_path.display()))
+        Err(err)
     }
     #[cfg(windows)]
     {
-        let status = cmd
-            .status()
-            .with_context(|| format!("failed to run {}", cli_path.display()))?;
-        Ok(ExitCode::from(status.code().unwrap_or(1) as u8))
+        use windows_sys::Win32::Foundation::{BOOL, FALSE, TRUE};
+        use windows_sys::Win32::System::Console::SetConsoleCtrlHandler;
+
+        unsafe extern "system" fn ctrlc_handler(_: u32) -> BOOL {
+            // Do nothing. Let the child process handle it.
+            TRUE
+        }
+        unsafe {
+            if SetConsoleCtrlHandler(Some(ctrlc_handler), TRUE) == FALSE {
+                return Err(io::Error::new(io::ErrorKind::Other, "Unable to set console handler"));
+            }
+        }
+
+        cmd.status()
+            .map(|status| ExitCode::from(status.code().unwrap_or(1).try_into().unwrap_or(1)))
     }
 }