313 lines
11 KiB
Rust
313 lines
11 KiB
Rust
// Learn more about Tauri commands at https://tauri.app/develop/calling-rust/
|
|
|
|
use std::collections::HashMap;
|
|
use std::fs::File;
|
|
use std::path::Path;
|
|
|
|
use bzip2::read::BzDecoder;
|
|
use flate2::read::GzDecoder;
|
|
use tar::Archive as TarArchive;
|
|
use tauri::async_runtime::spawn_blocking;
|
|
use xz2::read::XzDecoder;
|
|
use zip::ZipArchive;
|
|
|
|
/// Strip a single top-level directory if the target directory contains only one subdirectory.
|
|
/// This is useful after extracting archives that create an unnecessary parent folder.
|
|
/// Returns true if flattening was performed, false otherwise.
|
|
fn strip_single_top_level_directory(target_dir: &Path) -> Result<bool, std::io::Error> {
|
|
use std::fs;
|
|
|
|
let entries: Vec<_> = fs::read_dir(target_dir)?
|
|
.filter_map(|entry| entry.ok())
|
|
.collect();
|
|
|
|
// If there's exactly one entry and it's a directory, flatten it
|
|
if entries.len() == 1 {
|
|
let entry = &entries[0];
|
|
if entry.path().is_dir() {
|
|
let subdir_path = entry.path();
|
|
let subdir_name = entry.file_name();
|
|
|
|
// Move all items from subdirectory to target directory
|
|
for sub_entry in fs::read_dir(&subdir_path)? {
|
|
let sub_entry = sub_entry?;
|
|
let source_path = sub_entry.path();
|
|
let dest_path = target_dir.join(sub_entry.file_name());
|
|
fs::rename(&source_path, &dest_path)?;
|
|
}
|
|
|
|
// Remove the now-empty subdirectory
|
|
fs::remove_dir(&subdir_path)?;
|
|
|
|
println!(
|
|
"Flattened directory structure: removed {}/",
|
|
subdir_name.to_string_lossy()
|
|
);
|
|
return Ok(true);
|
|
}
|
|
}
|
|
|
|
Ok(false)
|
|
}
|
|
|
|
#[tauri::command]
|
|
fn launch_binary(
|
|
path: String,
|
|
args: Vec<String>,
|
|
env: Option<HashMap<String, String>>,
|
|
) -> Result<String, String> {
|
|
use std::process::{Command, Stdio};
|
|
let mut command = Command::new(path);
|
|
command
|
|
.args(args)
|
|
.stdin(Stdio::null())
|
|
.stdout(Stdio::null())
|
|
.stderr(Stdio::null());
|
|
|
|
if let Some(env_vars) = env {
|
|
command.envs(env_vars);
|
|
}
|
|
|
|
command
|
|
.spawn()
|
|
.map(|_| "Launched".into())
|
|
.map_err(|e| e.to_string())
|
|
}
|
|
|
|
/// Extract a ZIP archive to a target directory
|
|
#[tauri::command]
|
|
fn extract_zip(archive_path: String, target_dir: String) -> Result<String, String> {
|
|
let archive_file = File::open(&archive_path)
|
|
.map_err(|e| format!("Failed to open ZIP archive at {}: {}", archive_path, e))?;
|
|
|
|
let mut archive = ZipArchive::new(archive_file)
|
|
.map_err(|e| format!("Failed to read ZIP archive at {}: {}", archive_path, e))?;
|
|
|
|
for i in 0..archive.len() {
|
|
let mut file = archive
|
|
.by_index(i)
|
|
.map_err(|e| format!("Failed to read file {} in ZIP archive: {}", i, e))?;
|
|
|
|
let outpath = Path::new(&target_dir).join(file.mangled_name());
|
|
|
|
if file.name().ends_with('/') {
|
|
// Directory entry
|
|
std::fs::create_dir_all(&outpath)
|
|
.map_err(|e| format!("Failed to create directory {}: {}", outpath.display(), e))?;
|
|
} else {
|
|
// File entry
|
|
if let Some(parent) = outpath.parent() {
|
|
std::fs::create_dir_all(parent).map_err(|e| {
|
|
format!(
|
|
"Failed to create parent directory {}: {}",
|
|
parent.display(),
|
|
e
|
|
)
|
|
})?;
|
|
}
|
|
|
|
let mut outfile = File::create(&outpath)
|
|
.map_err(|e| format!("Failed to create file {}: {}", outpath.display(), e))?;
|
|
|
|
std::io::copy(&mut file, &mut outfile)
|
|
.map_err(|e| format!("Failed to write file {}: {}", outpath.display(), e))?;
|
|
}
|
|
}
|
|
|
|
// Strip single top-level directory if archive created one
|
|
let target_path = Path::new(&target_dir);
|
|
if let Err(e) = strip_single_top_level_directory(target_path) {
|
|
println!("Warning: Failed to strip top-level directory: {}", e);
|
|
}
|
|
|
|
Ok(format!(
|
|
"Successfully extracted ZIP archive to {}",
|
|
target_dir
|
|
))
|
|
}
|
|
|
|
/// Extract a TAR archive (uncompressed)
|
|
#[tauri::command]
|
|
fn extract_tar(archive_path: String, target_dir: String) -> Result<String, String> {
|
|
let archive_file = File::open(&archive_path)
|
|
.map_err(|e| format!("Failed to open TAR archive at {}: {}", archive_path, e))?;
|
|
|
|
let mut archive = TarArchive::new(archive_file);
|
|
|
|
archive
|
|
.unpack(&target_dir)
|
|
.map_err(|e| format!("Failed to extract TAR archive to {}: {}", target_dir, e))?;
|
|
|
|
// Strip single top-level directory if archive created one
|
|
let target_path = Path::new(&target_dir);
|
|
if let Err(e) = strip_single_top_level_directory(target_path) {
|
|
println!("Warning: Failed to strip top-level directory: {}", e);
|
|
}
|
|
|
|
Ok(format!(
|
|
"Successfully extracted TAR archive to {}",
|
|
target_dir
|
|
))
|
|
}
|
|
|
|
/// Extract a TAR.GZ archive
|
|
#[tauri::command]
|
|
fn extract_tar_gz(archive_path: String, target_dir: String) -> Result<String, String> {
|
|
let archive_file = File::open(&archive_path)
|
|
.map_err(|e| format!("Failed to open TAR.GZ archive at {}: {}", archive_path, e))?;
|
|
|
|
let gz_decoder = GzDecoder::new(archive_file);
|
|
let mut archive = TarArchive::new(gz_decoder);
|
|
|
|
archive
|
|
.unpack(&target_dir)
|
|
.map_err(|e| format!("Failed to extract TAR.GZ archive to {}: {}", target_dir, e))?;
|
|
|
|
// Strip single top-level directory if archive created one
|
|
let target_path = Path::new(&target_dir);
|
|
if let Err(e) = strip_single_top_level_directory(target_path) {
|
|
println!("Warning: Failed to strip top-level directory: {}", e);
|
|
}
|
|
|
|
Ok(format!(
|
|
"Successfully extracted TAR.GZ archive to {}",
|
|
target_dir
|
|
))
|
|
}
|
|
|
|
/// Extract a TAR.XZ archive
|
|
#[tauri::command]
|
|
fn extract_tar_xz(archive_path: String, target_dir: String) -> Result<String, String> {
|
|
let archive_file = File::open(&archive_path)
|
|
.map_err(|e| format!("Failed to open TAR.XZ archive at {}: {}", archive_path, e))?;
|
|
|
|
let xz_decoder = XzDecoder::new(archive_file);
|
|
let mut archive = TarArchive::new(xz_decoder);
|
|
|
|
archive
|
|
.unpack(&target_dir)
|
|
.map_err(|e| format!("Failed to extract TAR.XZ archive to {}: {}", target_dir, e))?;
|
|
|
|
// Strip single top-level directory if archive created one
|
|
let target_path = Path::new(&target_dir);
|
|
if let Err(e) = strip_single_top_level_directory(target_path) {
|
|
println!("Warning: Failed to strip top-level directory: {}", e);
|
|
}
|
|
|
|
Ok(format!(
|
|
"Successfully extracted TAR.XZ archive to {}",
|
|
target_dir
|
|
))
|
|
}
|
|
|
|
/// Extract a TAR.BZ2 archive
|
|
#[tauri::command]
|
|
fn extract_tar_bz2(archive_path: String, target_dir: String) -> Result<String, String> {
|
|
let archive_file = File::open(&archive_path)
|
|
.map_err(|e| format!("Failed to open TAR.BZ2 archive at {}: {}", archive_path, e))?;
|
|
|
|
let bz_decoder = BzDecoder::new(archive_file);
|
|
let mut archive = TarArchive::new(bz_decoder);
|
|
|
|
archive
|
|
.unpack(&target_dir)
|
|
.map_err(|e| format!("Failed to extract TAR.BZ2 archive to {}: {}", target_dir, e))?;
|
|
|
|
// Strip single top-level directory if archive created one
|
|
let target_path = Path::new(&target_dir);
|
|
if let Err(e) = strip_single_top_level_directory(target_path) {
|
|
println!("Warning: Failed to strip top-level directory: {}", e);
|
|
}
|
|
|
|
Ok(format!(
|
|
"Successfully extracted TAR.BZ2 archive to {}",
|
|
target_dir
|
|
))
|
|
}
|
|
|
|
/// Detect archive type and extract it automatically
|
|
#[tauri::command(async)]
|
|
async fn extract_archive(archive_path: String, target_dir: String) -> Result<String, String> {
|
|
// Run extraction in a blocking task to avoid hanging the UI
|
|
spawn_blocking(move || {
|
|
let path = Path::new(&archive_path);
|
|
|
|
// Get file extension(s) to determine archive type
|
|
let extension = path
|
|
.extension()
|
|
.and_then(|ext| ext.to_str())
|
|
.unwrap_or("")
|
|
.to_lowercase();
|
|
|
|
let filename = path
|
|
.file_name()
|
|
.and_then(|name| name.to_str())
|
|
.unwrap_or("")
|
|
.to_lowercase();
|
|
|
|
// Check for multi-part extensions like .tar.gz
|
|
if filename.ends_with(".tar.xz") || filename.ends_with(".txz") {
|
|
extract_tar_xz(archive_path, target_dir)
|
|
} else if filename.ends_with(".tar.gz") || filename.ends_with(".tgz") {
|
|
extract_tar_gz(archive_path, target_dir)
|
|
} else if filename.ends_with(".tar.bz2")
|
|
|| filename.ends_with(".tbz2")
|
|
|| filename.ends_with(".tbz")
|
|
{
|
|
extract_tar_bz2(archive_path, target_dir)
|
|
} else if extension == "tar" {
|
|
extract_tar(archive_path, target_dir)
|
|
} else if extension == "zip" {
|
|
extract_zip(archive_path, target_dir)
|
|
} else {
|
|
// Try ZIP first (common), then TAR
|
|
match extract_zip(archive_path.clone(), target_dir.clone()) {
|
|
Ok(result) => Ok(result),
|
|
Err(_) => {
|
|
// Try as uncompressed TAR
|
|
match extract_tar(archive_path, target_dir) {
|
|
Ok(result) => Ok(result),
|
|
Err(e) => Err(format!("Failed to extract archive. Supported formats: .zip, .tar, .tar.gz, .tar.xz, .tar.bz2. Error: {}", e))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
})
|
|
.await
|
|
.map_err(|e| format!("Blocking task failed: {}", e))?
|
|
}
|
|
|
|
#[cfg_attr(mobile, tauri::mobile_entry_point)]
|
|
pub fn run() {
|
|
tauri::Builder::default()
|
|
.plugin(tauri_plugin_updater::Builder::new().build())
|
|
.plugin(tauri_plugin_upload::init())
|
|
.plugin(tauri_plugin_shell::init())
|
|
.plugin(tauri_plugin_fs::init())
|
|
.plugin(tauri_plugin_persisted_scope::init())
|
|
.plugin(tauri_plugin_store::Builder::new().build())
|
|
.plugin(tauri_plugin_os::init())
|
|
.plugin(tauri_plugin_notification::init())
|
|
.plugin(tauri_plugin_http::init())
|
|
.plugin(tauri_plugin_dialog::init())
|
|
.plugin(tauri_plugin_window_state::Builder::new().build())
|
|
.plugin(tauri_plugin_opener::init())
|
|
.setup(|app| {
|
|
#[cfg(desktop)]
|
|
app.handle()
|
|
.plugin(tauri_plugin_window_state::Builder::default().build())?;
|
|
Ok(())
|
|
})
|
|
.invoke_handler(tauri::generate_handler![
|
|
extract_zip,
|
|
extract_tar,
|
|
extract_tar_gz,
|
|
extract_tar_xz,
|
|
extract_tar_bz2,
|
|
extract_archive,
|
|
launch_binary
|
|
])
|
|
.run(tauri::generate_context!())
|
|
.expect("error while running tauri application");
|
|
}
|