Initial set of changes to get and shut down ETVR backend from within the new frontend tool (#30)

* Initial set pf changes to get and shut down ETVR backend from within the new frontend tool

* Clean up the code.

TODO figure out how to kill a zombie proces

* Update tauri version

* You can't have a zombie process if you shoot it with a gun

* Cleanup after CR by FelinDev

 [FelinDev](https://github.com/felindev)

* Move the ETVR handling code into a plugin, update readme, clean up a little

Author: lorow

README.md

@@ -22,14 +22,33 @@ This project uses `pnpm` by default, and utilizes `pnpm workspaces`. If you do n
 You _can_ use `yarn` or `npm`, however, _you_ will need to modify the project to remove the `pnpm` specific commands and workspace.
 
 ## Setup
+### Step 1 - setup node environment
 
-This project uses custom `Tauri Plugins` to communicate with the hardware. These plugins are located in the [`src-tauri/src/lib`](/src-tauri/src/lib) folder.
+```bash
+pnpm run setup
+```
+### Step 2 - setting up the backend binary
 
-> [!WARNING]\
-> You **must** run the following command to install the project deps and build the plugins before running the app:
+To actually compile the project, you'll also need a binary of the ETVR backend from [here]().
+
+Clone the project, follow its readme to set it up and build the binary. 
+Once done, copy the result into [backend_bin](/src-tauri/backend_bin) and rename it to `ETVR-<target-triple>`
+
+The target triple can be obtained by running 
 
 ```bash
-pnpm run setup
+rustc -Vv
+```
+
+The info you're looking for will be stored under `host:`, for example `host: x86_64-pc-windows-msvc`
+So the copied binary should be named like `ETVR-x86_64-pc-windows-msvc`
+
+### Step 3
+
+Run the project
+
+```bash
+pnpm tauri dev
 ```
 
 ## Available Scripts
@@ -56,6 +75,11 @@ Runs `eslint` on all of the included files.
 
 Uses `Prettier` and the above `pnpm lint` command to lint and then format all included file types.
 
+## Development
+
+This project follows the architecture Tauri laid down - `Tauri Plugins` and commands, to communicate with the hardware. 
+These plugins are located in the [`src-tauri/src/lib`](/src-tauri/src/lib) folder.
+
 ## Deployment
 
 To build the app, run the following:

src-tauri/Cargo.lock

@@ -12,7 +12,6 @@ rust-version = "1.69"
 [dependencies]
 serde_json = "1.0"
 zip-extract = "0.1.3"
-command-group = "2.1.0"
 
 [dependencies.reqwest]
 workspace = true
@@ -41,6 +40,9 @@ path = "src/lib/api"
 [dependencies.tauri-plugin-esp]
 path = "src/lib/esp"
 
+[dependencies.tauri-plugin-etvr-backend]
+path = "src/lib/etvr_backend_module"
+
 [dependencies.tauri-plugin-window-state]
 git = "https://github.com/tauri-apps/plugins-workspace"
 branch = "v1"
@@ -66,7 +68,7 @@ version = "1"
 features = ["full"]
 
 [workspace]
-members = ["src/lib/api", "src/lib/util", "src/lib/esp"]
+members = ["src/lib/api", "src/lib/util", "src/lib/esp", "src/lib/etvr_backend_module"]
 
 [workspace.dependencies]
 dialoguer = "0.11.0"
@@ -90,7 +92,7 @@ features = ["javascript", "typescript"]
 
 [workspace.dependencies.tauri]
 version = "1.6.1"
-features = ["process-exit", "protocol-asset", "fs-all", "dialog-all", "http-all", "icon-ico", "notification-all", "os-all", "path-all", "process-relaunch", "shell-open", "system-tray", "window-center", "window-close", "window-create", "window-hide", "window-maximize", "window-minimize", "window-request-user-attention", "window-set-decorations", "window-set-focus", "window-set-fullscreen", "window-set-position", "window-set-resizable", "window-set-size", "window-set-title", "window-show", "window-start-dragging", "window-unmaximize", "window-unminimize"]
+features = ["process-exit", "protocol-asset", "fs-all", "dialog-all", "http-all", "icon-ico", "notification-all", "os-all", "path-all", "process-relaunch", "shell-all", "system-tray", "window-center", "window-close", "window-create", "window-hide", "window-maximize", "window-minimize", "window-request-user-attention", "window-set-decorations", "window-set-focus", "window-set-fullscreen", "window-set-position", "window-set-resizable", "window-set-size", "window-set-title", "window-show", "window-start-dragging", "window-unmaximize", "window-unminimize"]
 
 [features]
 default = ["custom-protocol"]
@@ -101,9 +103,6 @@ updater = ["tauri/updater"]
 version = "1.5.1"
 features = []
 
-[profile.dev]
-debug = 0
-
 [profile.release]
 panic = "abort"
 codegen-units = 1

src-tauri/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "tauri-plugin-etvr-backend"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+tauri = { workspace = true }
+log = { workspace = true }
+command-group = "2.1.0"
+reqwest = "0.11.27"

src-tauri/backend_bin/.gitkeep

@@ -0,0 +1,52 @@
+use crate::constants::ETVR_BACKEND_PORT;
+use command_group::CommandGroup;
+use std::process::Command;
+use std::sync::mpsc::Receiver;
+use std::thread;
+use tauri::api::process::Command as TauriCommand;
+use tauri::{AppHandle, Manager, Runtime};
+
+pub fn initialize_etvr_backend<R: Runtime>(app: AppHandle<R>, receiver: Receiver<()>) {
+  let sidecar_handle_result = TauriCommand::new_sidecar("ETVR");
+  match sidecar_handle_result {
+    Ok(handle) => {
+      spawn_backend(handle, receiver);
+    }
+    Err(spawn_error) => {
+      if let Some(window) = app.get_window("main") {
+        if let Err(error) = window.emit("backend-init-fail", spawn_error.to_string()) {
+          log::error!("failed to emit error event: {}", error);
+        }
+      }
+      log::error!("failed to start ETVR backend");
+    }
+  }
+}
+
+fn spawn_backend(sidecar_handle: TauriCommand, receiver: Receiver<()>) {
+  let mut group = Command::from(sidecar_handle)
+    .args(["--port", ETVR_BACKEND_PORT])
+    .group_spawn()
+    .expect("Failed to spawn ETVR backend");
+
+  log::info!("ETVR backend spawned");
+
+  // TODO this is fine for a happy-path scenario, we need a way to
+  // we'll also need to handle situations where the user quits forcefully
+  // or the app gets somehow killed
+  // something like a daemon process holding a socket to ETVR and a PID of the backend
+  // that once the socket gets closed - kills the backend and terminates, could work
+
+  thread::spawn(move || loop {
+    let signal = receiver.recv();
+    match signal {
+      Ok(_) => {
+        log::info!("ETVR backend terminated.");
+        group.kill().expect("failed to kill ETVR backend");
+      }
+      Err(e) => {
+        log::error!("How is this possible? This should not error out: {:?}", e);
+      }
+    }
+  });
+}

src-tauri/src/lib/etvr_backend_module/Cargo.toml

@@ -0,0 +1,33 @@
+use std::sync::mpsc::SendError;
+use tauri::{AppHandle, Manager, Runtime};
+use crate::constants::{ETVR_BACKEND_ADDRESS, ETVR_BACKEND_PORT};
+use crate::state::AppState;
+
+#[tauri::command(async)]
+pub async fn shutdown_etvr_backend<R: Runtime>(app_handle: AppHandle<R>) -> Result<(), String> {
+  // requesting shutdown will immediately kill the backend so we can safely ignore the result here
+  // but for some reason the process will still be somewhat alive, a zombie
+  // we gotta kill it.
+
+  // TODO change the port, random it get something bigger, 8000 is not good enough
+  let _ = reqwest::get(format!(
+    "http://{}:{}/etvr/shutdown",
+    ETVR_BACKEND_ADDRESS, ETVR_BACKEND_PORT
+  ))
+  .await;
+
+  let app_state = app_handle.state::<AppState>();
+
+  log::info!("ETVR Backend shutdown successfully");
+  match app_state.inner().sidecar_sender.send(()) {
+    Ok(_) => {
+      log::info!("ETVR Backend process killed successfully");
+    }
+    Err(error) => {
+      log::error!("Failed to kill ETVR Backend process with error: {}", error);
+    }
+  }
+
+  app_handle.exit(0);
+  Ok(())
+}

src-tauri/src/lib/etvr_backend_module/src/client.rs

@@ -0,0 +1,6 @@
+pub const ETVR_BACKEND_ADDRESS: &str = "127.0.0.1";
+
+// by default the backend server will be running on port 8000
+// which is super common in dev, so we gotta adjust.
+// TODO move this to a configuration file
+pub const ETVR_BACKEND_PORT: &str = "8855";