Sidecar process is still alive when the main process exits

[zzl221000]

First of all, I think this project is really great!❤
But I have encountered a little problem in using it.
I have embedded an aria2 downloader in the program using Sidecar. Everything was working fine until I closed the program and found that the aria2 process was still alive.
How should I deal with this problem?

I solved it in the following way for now. But I think it is the wrong way.

pub struct MyCommandChild {
  pub inner: Arc<SharedChild>,
  pub stdin_writer: PipeWriter,
}
thread::spawn(move || {
        let child = spawn_aria2c_server();
        let my_child: MyCommandChild = unsafe {
          std::mem::transmute(child)
        };
        let sc = my_child.inner;

        window.on_window_event(move |event|
          match event {
            WindowEvent::Destroyed =>{match sc.kill(){
              Ok(_) => {println!("shutdown aria2 server success")}
              Err(_) => {eprintln!("shutdown aria2 server failed,please close by self")}
            };}
            _ => {}
          }
        )
      });

[lucasfernog]

Process cleanup must be done manually :( I think we can do it on our end for sidecar processes though.

[selfconfigio]

@lucasfernog Do you know how specify to tauri to keep the sidecar process alive since now it is killed by default?

[FabianLars]

You could listen to the ExitRequested RunEvent like this:

tauri/examples/api/src-tauri/src/main.rs

Lines 242 to 244 in b02fc90

	RunEvent::ExitRequested { api, .. } => {
	api.prevent_exit();
	}

and then use std::process::exit(0) to exit the app instead of Tauri's exit. This will skip the sidecar cleanup but also the system tray cleanup :/

p.s. not sure if that's actually enough to keep the process running, but this removes Tauri's manual clean-up

[selfconfigio]

@FabianLars Nice, I never noticed this part of the API
I was able to keep the process alive when combining this with std::process::Command over tauri::api::process::Command
To future readers, the tauri config I used to achieve the behaviour of non killed exes when tauri exits also included:

    "allowlist": {
      "shell": {
        "scope": [
          {
            "name": "resources/my_bin1",
            "args": true,
            "sidecar": true // I don't think this is necessary actually with std::process
          },
          {
            "name": "resources/my_bin2.exe",
            "args": true,
            "sidecar": true // I don't think this is necessary actually with std::process
          }
        ],
        "execute": true,
        "open": true,
        "sidecar": true // I don't think this is necessary actually with std::process
      }
    },
    "bundle": {
      "externalBin": [
      ],
       // Using resources over externalBin, since the binaries are already cross platform/handled
      "resources": [
        "resources/my_bin1",
        "resources/my_bin2.exe",
        "resources/a_normal_resource.png",
      ]
    }

[FabianLars]

Forgot to mention that stuff, you can also convert sidecars to std commands (in case you wanna use sidecars instead of resources). Something like this iirc

let tauri_cmd = tauri::process::Command::new_sidecar("sidecar").unwrap();
let std_cmd = std::process::Command::from(tauri_cmd);

[CMiller3]

Hi FabianLars -

For some reason I'm attempting to recreate what you suggested, and even attempted to follow the tauri::api::process::Command -> from(cmd: Command) -> StdCommand, but for some reason I get this error:

mismatched types
expected struct `std::process::Command`, found struct `tauri::api::process::Command`

type StdCommand = std::process::Command;
type SideCarCommand = tauri::api::process::Command;

let tauri_cmd: SideCarCommand = SideCarCommand::new_sidecar("mpvote-processor").unwrap();
let std_cmd: StdCommand = SideCarCommand::from(tauri_cmd);

Edit: I'm a Swift first developer, and I seriously need to work more on FnMut and such... here was my workaround if it helps anyone:

RunEvent::ExitRequested { api, .. } => {
println!("EXIT IS REQUESTED {}", pid);

        let output = if cfg!(target_os = "windows") {
            Command::new("cmd")
                    .args(["taskkill", "-f", "-im", "processName"])
                    .output()
                    .expect("failed to execute process")
        } else {
            Command::new("sh")
                    .args(["pkill -f processName"])
                    .output()
                    .expect("failed to execute process")

        };
        
    }

[FabianLars]

The last line was wrong, it'd be StdCommand::from not SidecarCommand::from. Glad you found another way in the meantime