stop ignoring cef commands

Signed-off-by: NikitaSkrynnik <[email protected]>

Author: NikitaSkrynnik

.gitignore

@@ -1,5 +1,5 @@
 node_modules
 dist
-cef
+src-tauri/cef
 
 .DS_Store

src-tauri/src/cef/mod.rs

@@ -0,0 +1,91 @@
+use std::{
+    fs,
+    process::Command,
+    sync::{Arc, Mutex},
+};
+
+use tauri::Manager;
+
+use crate::{
+    BrowserState,
+    cef::utils::{
+        compare_checksums, copy_dir_all, download_and_extract, find_available_port, get_cef_paths,
+        wait_for_cef,
+    },
+};
+
+mod utils;
+
+#[cfg(target_os = "linux")]
+const CEF_URL: &str =
+    "https://github.com/hulylabs/huly-cef/releases/latest/download/huly-cef-linux.zip";
+#[cfg(target_os = "macos")]
+const CEF_URL: &str =
+    "https://github.com/hulylabs/huly-cef/releases/latest/download/huly-cef-macos.zip";
+#[cfg(target_os = "windows")]
+const CEF_URL: &str =
+    "https://github.com/hulylabs/huly-cef/releases/latest/download/huly-cef-windows.zip";
+
+#[cfg(target_os = "linux")]
+const CEF_EXE: &str = "huly-cef-websockets";
+#[cfg(target_os = "macos")]
+const CEF_EXE: &str = "huly-cef-websockets.app/Contents/MacOS/huly-cef-websockets";
+#[cfg(target_os = "windows")]
+const CEF_EXE: &str = "huly-cef-websockets.exe";
+
+#[tauri::command]
+pub fn is_cef_present(app_handle: tauri::AppHandle) -> Result<bool, String> {
+    let (cef_dir, _) = get_cef_paths(&app_handle)?;
+    compare_checksums(CEF_URL, cef_dir.join("checksum"))
+}
+
+#[tauri::command]
+pub fn download_cef(app_handle: tauri::AppHandle) -> Result<(), String> {
+    let (cef_dir, _) = get_cef_paths(&app_handle)?;
+    let result = download_and_extract(CEF_URL, &cef_dir);
+    if result.is_err() {
+        _ = fs::remove_dir_all(&cef_dir);
+        return result;
+    }
+
+    Ok(())
+}
+
+#[tauri::command]
+pub async fn launch_cef(app_handle: tauri::AppHandle) -> Result<String, String> {
+    let (cef_dir, cef_cache) = get_cef_paths(&app_handle)?;
+
+    let temp_cef_dir = std::env::temp_dir().join("huly-cef");
+    _ = fs::remove_dir_all(&temp_cef_dir);
+    copy_dir_all(&cef_dir, &temp_cef_dir).map_err(|e| format!("failed to copy CEF: {e}"))?;
+
+    let cef_exe = temp_cef_dir.join(CEF_EXE);
+
+    let port = find_available_port().map_err(|e| format!("couldn't find available port: {e}"))?;
+    let mut command = Command::new(cef_exe);
+    command
+        .args(["--port", &port.to_string()])
+        .args(["--cache-path", cef_cache.to_str().unwrap()]);
+
+    #[cfg(target_os = "windows")]
+    {
+        use std::os::windows::process::CommandExt;
+        command.creation_flags(0x08000000);
+    }
+
+    let cef = command.spawn().map_err(|e| {
+        format!("failed to launch CEF with params port {port} cache-dir {cef_cache:?}: {e}")
+    })?;
+
+    wait_for_cef(port).map_err(|e| {
+        format!("CEF failed to start with params port {port} cache-dir {cef_cache:?}: {e}")
+    })?;
+
+    app_handle
+        .state::<Arc<Mutex<BrowserState>>>()
+        .lock()
+        .unwrap()
+        .cef_process = Some(cef);
+
+    Ok(format!("ws://localhost:{port}/browser"))
+}

src-tauri/src/cef/utils.rs

@@ -0,0 +1,106 @@
+use std::{
+    fs,
+    io::{self, Cursor},
+    net::TcpListener,
+    path::{Path, PathBuf},
+};
+
+use tauri::Manager;
+use tungstenite::connect;
+use zip::ZipArchive;
+
+pub fn copy_dir_all(src: impl AsRef<Path>, dst: impl AsRef<Path>) -> io::Result<()> {
+    fs::create_dir_all(&dst)?;
+    for entry in fs::read_dir(src)? {
+        let entry = entry?;
+        let ty = entry.file_type()?;
+        if ty.is_dir() {
+            copy_dir_all(entry.path(), dst.as_ref().join(entry.file_name()))?;
+        } else {
+            fs::copy(entry.path(), dst.as_ref().join(entry.file_name()))?;
+        }
+    }
+    Ok(())
+}
+
+pub fn get_cef_paths(app_handle: &tauri::AppHandle) -> Result<(PathBuf, PathBuf), String> {
+    let app_resource_dir = app_handle
+        .path()
+        .resource_dir()
+        .map_err(|_| "app resource directory not found")?;
+    let app_cache_dir = app_handle
+        .path()
+        .app_cache_dir()
+        .map_err(|_| "app cache directory not found")?;
+
+    let cef_dir = app_resource_dir.join("cef");
+    let cef_cache = app_cache_dir.join("cefcache");
+
+    Ok((cef_dir, cef_cache))
+}
+
+pub fn wait_for_cef(port: u16) -> Result<(), String> {
+    for _ in 0..10 {
+        std::thread::sleep(std::time::Duration::from_millis(500));
+        if healthcheck("localhost", port) {
+            return Ok(());
+        }
+    }
+
+    Err("CEF healthcheck failed".into())
+}
+
+pub fn healthcheck(host: &str, port: u16) -> bool {
+    let address = format!("ws://{}:{}", host, port);
+    connect(address.clone()).is_ok()
+}
+
+pub fn find_available_port() -> Result<u16, String> {
+    for port in 10000..50000 {
+        if let Ok(_) = TcpListener::bind(format!("0.0.0.0:{}", port)) {
+            return Ok(port);
+        }
+    }
+    Err("No available ports found".into())
+}
+
+pub fn compare_checksums(url: &str, checksum_path: impl AsRef<Path>) -> Result<bool, String> {
+    let existing = fs::read_to_string(checksum_path)
+        .map_err(|e| format!("failed to read existing checksum: {e}"))?;
+    let new = download_checksum(url)?;
+
+    Ok(existing == new)
+}
+
+pub fn download_checksum(url: &str) -> Result<String, String> {
+    let checksum = reqwest::blocking::get(format!("{url}.sha256"))
+        .map_err(|e| format!("failed to download checksum: {e}"))?
+        .text()
+        .map_err(|e| format!("failed to read checksum response: {e}"))?;
+    Ok(checksum)
+}
+
+pub fn download_and_extract(url: &str, dir: impl AsRef<Path>) -> Result<(), String> {
+    _ = fs::remove_dir_all(&dir);
+    fs::create_dir_all(&dir).map_err(|e| format!("failed to create CEF dir: {e}"))?;
+
+    let data = reqwest::blocking::get(url)
+        .and_then(|r| r.bytes())
+        .and_then(|b| Ok(b.to_vec()))
+        .map_err(|e| format!("failed to download CEF: {e}"))?;
+
+    ZipArchive::new(Cursor::new(data))
+        .and_then(|mut archive| archive.extract(&dir))
+        .map_err(|e| {
+            format!(
+                "failed to extract CEF archive to {}: {e}",
+                dir.as_ref().display()
+            )
+        })?;
+
+    let checksum = download_checksum(url)?;
+    fs::write(dir.as_ref().join("checksum"), checksum)
+        .map_err(|e| format!("failed to save checksum: {e}"))?;
+
+    Ok(())
+}