Kill process on exit

[anytechie]

Hi, thanks for this wonderful library. I want to know how to kill process started with use std::process::Command

This is my code to start tauri app as well as a flask server:

#![cfg_attr(
  all(not(debug_assertions), target_os = "windows"),
  windows_subsystem = "windows"
)]

use std::process::Command;
use std::os::windows::process::CommandExt;

#[tauri::command]
fn start_server() {
  Command::new("./app-x86_64-pc-windows-msvc.exe")
    .arg("8080")
    .creation_flags(0x08000000) // hide console window
    .spawn()
    .expect("Failed to start the server");
}

fn main() {
  tauri::Builder::default()
    .setup(|app| {
      tauri::async_runtime::spawn(async move {
        start_server();
      });
      Ok(())
    })
    .run(tauri::generate_context!())
    .expect("error while running tauri application");
}

[FabianLars]

Command.spawn() returns a Child. That child should be Send&Sync so you can move it around and store it quite easily. You can then call child.kill() to kill the process.
If we're talking about killing it on app exit you can use the CloseRequested and/or ExistRequested events for this, for an example see here.

For storing the child you can use stuff like once_cell or tauri's built-in State.

Alternatively if this is a sidecar you can use tauris built-in Command::new_sidecar instead which uses the same creation_flag under the hood. This would have the sideeffect of tauri automatically trying to clean up those spawned children on app exit, while still providing a similar interface so you can kill it yourself.

[ThatXliner]

I am using the JS/TS API, spawning a non-sidecar process via .spawn(). Either SvelteKit isn't running the cleanup on HMR or killing the process doesn't kill the children's processes.

[vipierozan99]

I'm having the same problem, the sidecar process is not getting killed after I exit the window:

#[derive(Default)]
struct Backend(Option<CommandChild>);

fn main() {
    let mut backend = Backend::default();

    tauri::Builder::default()
        .build(tauri::generate_context!())
        .expect("Error building app")
        .run(move |app_handle, event| match event {
            RunEvent::Ready => {
                let (_, child) = Command::new_sidecar("backend_server")
                    .expect("Failed to create `backend_server` binary command")
                    .spawn()
                    .expect("Failed to spawn backend sidecar");

                _ = backend.0.insert(child);
            }
            RunEvent::ExitRequested { api, .. } => {
                if let Some(child) = backend.0.take() {
                    child.kill().expect("Failed to shutdown backend.");
                    println!("Backend gracefully shutdown.")
                }
            }      
            _ => {}
        });
}

I can see the println! in the terminal after I close the window, so the child.kill() line must be running, but when I check the process is still running. On the other hand if I kill the application in the terminal with Ctrl + C, Tauri automatically kills the sidecar process.

tauri = { version = "1.0.5", features = ["http-all", "process-command-api"] }

[FabianLars]

See this issue #4949. It's a little trickyyy, normally the main sidecar process is supposed to clean up its own children, but unfortunately it's quite common that they don't do it, which is why imo we need to look into providing a way to do that in Tauri (either directly inside Tauri or by at least giving users a way to handle it manually).

[vipierozan99]

@FabianLars thank you for pointing to that issue, I am also using pyinstaller with a flask backend, and with the PR #4836 I was able to:

use std::process::Command as StdCommand;
use tauri::api::process::Command;

let mut command = StdCommand::from(
    Command::new_sidecar("backend_server")
        .expect("Failed to create `backend_server` binary command"),
    );

Then using the command_group crate:

// spawn
let child = command.group_spawn().expect("Failed to spawn backend sidecar");
// then kill all
child.kill().expect("Failed to shutdown backend.");

Which successfully kills both the pyinstaller bootloader and flask processes (tested on linux only, but should work on other platforms as well)

[TheBlindM]

@FabianLars thank you for pointing to that issue, I am also using pyinstaller with a flask backend, and with the PR #4836 I was able to:

use std::process::Command as StdCommand;
use tauri::api::process::Command;

let mut command = StdCommand::from(
    Command::new_sidecar("backend_server")
        .expect("Failed to create `backend_server` binary command"),
    );

Then using the command_group crate:

// spawn
let child = command.group_spawn().expect("Failed to spawn backend sidecar");
// then kill all
child.kill().expect("Failed to shutdown backend.");

Which successfully kills both the pyinstaller bootloader and flask processes (tested on linux only, but should work on other platforms as well)

Do you have the complete code or demo? , I want to start a java service in it

[CyberQin]

#![cfg_attr(
all(not(debug_assertions), target_os = "windows"),
windows_subsystem = "windows"
)]
mod functions;

use std::process::Command;
use std::sync::mpsc::{sync_channel, Receiver};
use std::sync::Mutex;
use std::thread;
use command_group::{CommandGroup, GroupChild};
use tauri::api::process::Command as TCommand;
use sysinfo::{Pid, ProcessExt, Signal, System, SystemExt};
use tauri::WindowEvent;


fn start_backend(receiver: Receiver<i32>) {
  let t = TCommand::new_sidecar("windxapi")
    .expect("启动API服务器失败");
  let mut group = Command::from(t).group_spawn().expect("启动API失败");
  thread::spawn(move || {
    loop{
      let mut s = receiver.recv();
      if s.unwrap()==-1 {
        group.kill().expect("关闭API失败");
      }
    }
  });
}

fn main() {
  let (tx,rx) = sync_channel(1);
  start_backend(rx);
  tauri::Builder::default()
    .on_window_event(move |event| match event.event() {
      WindowEvent::Destroyed => {
        println!("准备关闭后台API");
        tx.send(-1).expect("发送关闭信号失败");
        println!("已关闭后台API");
      }
      _ => {}
    })
    // .invoke_handler(tauri::generate_handler![start_backend,terminate_backend,terminate_pid])
    .run(tauri::generate_context!())
    .expect("error while running tauri application");
}

@TheBlindM

[giiyms]

Wow this seems way more complicated than I had imagined. Thanks for the code will see if I can get mine working like yours.

[VEADoc]

@CyberQin niubility bro.

[CyberQin]

Recently, i update the method, no need to use oncell crate and global variable.
tauri has a statemanager , so i write a APIManager struct to control the sidecar, then use the statemanager to hold the APIManager struct instance!
It still need use Arc<Mutex<Option>> to wrap the instance because of multiprocess memory visit. But it's more clear to handle it.

[trymbill]

@CyberQin, you wouldn't happen to have an example for this? I'm working on something similar and would love to see how you implemented the tauri state manager instead of the global TX/RX channels.

[CyberQin]

@trymbill

#![cfg_attr(
    all(not(debug_assertions), target_os = "windows"),
    windows_subsystem = "windows"
)]

pub mod api_manager;
mod clipboards;

use api_manager::APIManager;
use std::sync::Mutex;
use tauri::{Manager, State, WindowEvent};

struct APIManagerState {
    api_manager_mutex: Mutex<APIManager>,
}

#[tauri::command]
fn start_server(api_manager_state: State<APIManagerState>) -> Result<String, String> {
    let am = api_manager_state
        .api_manager_mutex
        .lock()
        .unwrap()
        .start_backend();
    am
}

#[tauri::command]
fn stop_server(api_manager_state: State<APIManagerState>) -> Result<String, String> {
    let am = api_manager_state
        .api_manager_mutex
        .lock()
        .unwrap()
        .terminate_backend();
    am
}

#[tauri::command]
fn restart_server(api_manager_state: State<APIManagerState>) -> Result<String, String> {
    let am = api_manager_state
        .api_manager_mutex
        .lock()
        .unwrap()
        .restart_backend();
    am
}

fn main() {
    let api_manager = APIManager::new();
    let ams = APIManagerState {
        api_manager_mutex: Mutex::new(api_manager),
    };

    tauri::Builder::default()
        .manage(ams)
        .setup(move |app| {
            let am: State<APIManagerState> = app.state();
            #[cfg(not(debug_assertions))]
            am.api_manager_mutex
                .lock()
                .unwrap()
                .start_backend()
                .expect("backend start failed");
            Ok(())
        })
        .on_window_event(move |event| match event.event() {
            WindowEvent::Destroyed => {
                let am: State<APIManagerState> = event.window().state();
                am.api_manager_mutex
                    .lock()
                    .unwrap()
                    .terminate_backend()
                    .expect("");
            }
            _ => {}
        })
        .invoke_handler(tauri::generate_handler![
            start_server,
            stop_server,
            restart_server
        ])
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

Pls note that： i changed pyinstaller to onedir mode ,so i need use TauriCommand::new not sidecar . If you have a onefile package, still use sidecar and use command_group crate to hold sidecar child.

use std::borrow::BorrowMut;
use std::process::{Child, Command};
use tauri::api::process::Command as TCommand;

pub struct APIManager {
    cmd: Command,
    child: Option<Child>,
    // api_process: Option<GroupChild>,
}

impl APIManager {
    pub fn new() -> APIManager {
        // let t = TCommand::new_sidecar("windxapi").expect("启动API服务器失败");
        let tt = TCommand::new("./windx_api/windx_api");
        // let cmd_from_sidecar: Command = t.into();
        APIManager {
            cmd: tt.into(),
            child: None,
            // api_process: None,
        }
    }

    pub fn start_backend(&mut self) -> Result<String, String> {
        match self.child.borrow_mut() {
            Some(_) => {
                let info = "API服务子进程不为空，不再新建";
                println!("{}", &info);
                Ok(info.into())
            }
            None => {
                let child = self.cmd.spawn();
                match child {
                    Ok(v) => {
                        self.child = Some(v);
                        let info = "api start successful";
                        println!("{}", &info);
                        Ok(info.into())
                    }
                    Err(_) => {
                        let info = "api start failed";
                        println!("{}", &info);
                        Err(info.into())
                    }
                }
            }
        }     
    }

    pub fn terminate_backend(&mut self) -> Result<String, String> {
        match self.child.borrow_mut() {
            Some(child) => {
                // child.wait().expect("Some error happened when killing child process");
                child
                    .kill()
                    .expect("Some error happened when killing child process");
                self.child = None;
                let info = "Kill already existed child process then set it to None";
                println!("{}", &info);
                Ok(info.into())
            }
            _ => {
                let info = "API子进程当前不存在，无须操作";
                println!("{}", &info);
                Ok(info.into())
            }
        }
    }

    pub fn restart_backend(&mut self) -> Result<String, String> {
        let terminate_result = self.terminate_backend();
        match terminate_result {
            Ok(_) => {
                println!("已执行API终止动作");
                match self.start_backend() {
                    Ok(_) => {
                        let info = "重启API服务器成功";
                        println!("{}", &info);
                        Ok(info.into())
                    }
                    Err(e) => {
                        println!("{}", &e);
                        return Err(e.into());
                    }
                }
            }
            Err(e) => {
                println!("{}", &e);
                return Err(e);
            }
        }
    }
}

[nacodermer]

I recommend using the kill binary.
It is the simplest solution I have found so far.

use std::process::{Child, Command};

fn kill_process(child: &mut Child) -> Result<(), Box<dyn std::error::Error>> {
    #[cfg(unix)]
    {
        let pid = child.id().to_string();
        println!("Sending INT signal to process with PID: {}", pid);

        let mut kill = StdCommand::new("kill")
            .args(["-s", "SIGINT", &pid])
            .spawn()?;
        kill.wait()?;
    }

    #[cfg(windows)]
    {
        let pid = child.id().to_string();
        println!("Sending taskkill to process with PID: {}", pid);

        let mut kill = StdCommand::new("taskkill")
            .args(["/PID", &pid, "/F"])
            .spawn()?;
        kill.wait()?;
    }

    Ok(())
}

fn main() {
    let child = Command::new("your_process")
        .spawn()
        .expect("Failed to start process");

    // Simulate some work
    std::thread::sleep(std::time::Duration::from_secs(5));

    match kill_process(&child) {
        Ok(_) => println!("Process killed successfully."),
        Err(e) => eprintln!("Failed to kill process: {}", e),
    }
}

[nacodermer]

your_process.sh

pids=()
./run.sh & # your real code here
pids+=($!) 

cleanup() {
    echo "Cleaning up..."
    for pid in "${pids[@]}"; do
        echo "Killing child process $pid"
        kill -s SIGINT "$pid" 2>/dev/null
        echo "$$: kill -s SIGINT $pid" >> cleanup.log
    done
    exit 0
}

trap cleanup SIGHUP SIGINT SIGQUIT SIGTERM
wait

[nacodermer]

It's strange that this solution sometimes works very well, but when something like "node ./server/entry.fastify &" in "./run.sh" , sometimes it fails to close the "./run.sh"
only "your_process.sh" can always be closed
It seems like this is not a good idea

[nacodermer]

Add the following code to the front of your_process.sh file

set -m 

when something like "node ./server/entry.fastify &" in "./run.sh", It also needs to have cleaning steps similar to the above in run.sh.

After doing this, all processes can be shut down.

Pay special attention to the fact that SIGINT is used in all places for successful testing.

[gschier]

This won't work on Windows, though

[NetOpWibby]

Thanks to #3273 (comment) and #7558 (comment) I found a solution.

commands.rs

fn kill_process(pid: &str) -> Result<(), Box<dyn std::error::Error>> {
    #[cfg(unix)] {
        println!("Sending INT signal to process with PID: {}", pid);

        let mut kill = Command::new("kill")
            .args(["-s", "SIGINT", &pid])
            .spawn()?;
        kill.wait()?;
    }

    #[cfg(windows)] {
        println!("Sending taskkill to process with PID: {}", pid);

        let mut kill = StdCommand::new("taskkill")
            .args(["/PID", &pid, "/F"])
            .spawn()?;
        kill.wait()?;
    }

    Ok(())
}

#[tauri::command]
pub async fn quit_letsdane(pid: &str) -> Result<(), String> {
    match kill_process(pid) {
        Ok(_) => {
            println!("Process killed successfully.");
            Ok(())
        },
        Err(e) => {
            eprintln!("Failed to kill process: {}", e);
            Err(e.to_string())
        }
    }
}

#[tauri::command]
pub async fn start_letsdane(app: tauri::AppHandle) {
    let child = Command::new("/absolute/path/to/my/sidecar/executable-aarch64-apple-darwin")
        .args([
            "-r", "127.0.0.1:5350",
            "-addr", ":5555",
            "-skip-dnssec",
            "-skip-icann",
            "-conf", "/absolute/path/to/.config"
        ])
        .spawn()
        .expect("Failed to start process");

    let pid = child.id().to_string();
    app.emit("letsdane-pid", Payload { message: pid.to_string().into() }).unwrap();
}

main.rs

// ...
        .invoke_handler(tauri::generate_handler![
            commands::quit_letsdane,
            commands::start_letsdane
        ])
// ...

+page.svelte

  $: letsdanePID = 0;

  type Payload = {
    message: string;
  };

    const subMenu7 = await MenuItem.new({
      action: async() => {
        // TODO
        // : stop hnsd

        /// stop letsdane process
        await invoke("quit_letsdane", { pid: `${letsdanePID}` });

        await exit(0);
      },
      text: "Quit"
    });

  async function rustBackendListener() {
    await listen<Payload>("letsdane-pid", (event) => {
      console.log("Event triggered from rust!\nPayload: " + event.payload.message);
      letsdanePID = Number(event.payload.message);
      console.log(event.payload.message);
    });
  }

  onMount(async() => {
    await rustBackendListener();
    await invoke("start_letsdane");
    console.log(">>> letsdanePID", letsdanePID);
  });

My app will be open-source at some point but this is the gist.

[rangsaritv]

This seems to work for me in Tauri v2. Note that I use PyInstaller onefile which spawns 2 processes. Therefore, I also use STDIN to get some signal to terminate the other process.

use std::sync::{Arc, Mutex};
use tauri_plugin_shell::ShellExt;
use tauri::Manager;
use tauri::path::BaseDirectory;


#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
    tauri::Builder::default()
        .plugin(tauri_plugin_fs::init())
        .plugin(tauri_plugin_shell::init())
        .invoke_handler(tauri::generate_handler![greet])
        .setup(|app| {

            let resource_path = app
            .path().resolve("resources/info.log", BaseDirectory::Resource)?;    

            let sidecar_command = app.shell().sidecar("client2").unwrap().args([resource_path]);
            let ( _rx, sidecar_child) = sidecar_command
              .spawn()
              .expect("Failed to spawn sidecar");

            // Wrap the child process in Arc<Mutex<>> for shared access
            let child = Arc::new(Mutex::new(Some(sidecar_child)));

            // Clone the Arc to move into the async task
            let child_clone = Arc::clone(&child);


            let window = app.get_webview_window("main").unwrap();

            window.on_window_event( move |event| {
              if let tauri::WindowEvent::CloseRequested { .. } = event {

                let mut child_lock = child_clone.lock().unwrap();
                if let Some(mut child_process) = child_lock.take() {
                  if let Err(e) = child_process.write("Exit message from Rust\n".as_bytes())
                  {
                    println!("Fail to send to stdin of Python: {}", e);
                  }

                  if let Err(e) = child_process.kill() {
                      eprintln!("Failed to kill child process: {}", e);
                  }
                }
              }
            });

            Ok(())

          })
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

[rangsaritv]

I would do something like this in Python which will terminate the process upon an input from stdin.

import schedule
import time
import sys
import select
from datetime import datetime

def my_function():
    # Get the current date and time
    now = datetime.now()

    # Format the date and time
    formatted_datetime = now.strftime("%Y-%m-%d %H:%M:%S")

    # Print the formatted date and time
    print(formatted_datetime)
    print('test hohoho\n')

if __name__ == "__main__":
    ## Schedule the function to run every hour
    schedule.every(5).seconds.do(my_function)

    while True:
        # Check if a scheduled task is pending to run or not
        schedule.run_pending()
        time.sleep(.3)
        if select.select([sys.stdin], [], [], 0.1)[0]:
            line = sys.stdin.readline().strip()
            if line:
                print(f"Received input: {line}")
                break

[akbarpn136]

It works nicely for Tauri V2, thank you

[yann-dubrana]

For anyone encountering the same issue, I’ve created a repository demonstrating a working solution. You can find it here: tauri-tensorflow-template. Feel free to explore the implementation, and I hope it helps! Feedback or suggestions are welcome.

[NetOpWibby]

Why not just link directly? https://github.com/yann-dubrana/tauri-tensorflow-template/blob/master/src-tauri/src/server.rs#L61-L70

[yann-dubrana]

Why not just link directly? https://github.com/yann-dubrana/tauri-tensorflow-template/blob/master/src-tauri/src/server.rs#L61-L70

i have made it this way to handle both onefile and multifile pyinstaller configuration. but i'm not an experienced rust developper so this is maybe bad design.