initial commit

src-tauri/src/lib.rs

@@ -0,0 +1,24 @@
+mod unpacker;
+
+use tauri::Runtime;
+use unpacker::unpack;
+
+#[tauri::command]
+async fn unpack_debug<R: Runtime>(
+    app: tauri::AppHandle<R>,
+    window: tauri::Window<R>,
+) -> Result<String, String> {
+    
+    unpack().unwrap();
+    
+    return Ok("Successful".to_string());
+}
+
+#[cfg_attr(mobile, tauri::mobile_entry_point)]
+pub fn run() {
+    tauri::Builder::default()
+        .plugin(tauri_plugin_shell::init())
+        .invoke_handler(tauri::generate_handler![unpack_debug])
+        .run(tauri::generate_context!())
+        .expect("error while running tauri application");
+}

src-tauri/src/main.rs

@@ -0,0 +1,6 @@
+// Prevents additional console window on Windows in release, DO NOT REMOVE!!
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+
+fn main() {
+    drop_app_lib::run()
+}

src-tauri/src/unpacker.rs

@@ -0,0 +1,93 @@
+use ciborium::from_reader;
+use rayon::iter::{IntoParallelIterator, ParallelIterator};
+use serde::Deserialize;
+use std::{
+    collections::HashMap,
+    fs::{create_dir_all, File},
+    io::{self, BufReader, Error, Seek},
+    os::unix::fs::PermissionsExt,
+    path::Path,
+};
+use tauri::Runtime;
+use xz2::bufread::XzDecoder;
+
+#[derive(Deserialize)]
+struct ManifestChunk {
+    uuid: String,
+    index: i64,
+}
+
+#[derive(Deserialize)]
+struct ManifestRecord {
+    chunks: Vec<ManifestChunk>,
+    permissions: Vec<bool>,
+}
+
+#[derive(Deserialize)]
+struct Manifest {
+    record: HashMap<String, ManifestRecord>,
+}
+
+fn generate_permissions(permissions: Vec<bool>) -> u32 {
+    // Base 8
+    let mut perms: u32 = 0;
+
+    // Read
+    if permissions[0] {
+        perms += 4;
+    }
+
+    // Write
+    if permissions[1] {
+        perms += 2;
+    }
+
+    // Execute
+    if permissions[2] {
+        perms += 1;
+    }
+
+    perms *= 8 * 8;
+    perms += 4 * 8 + 4;
+
+    return perms;
+}
+
+pub fn unpack() -> Result<(), Error> {
+    let chunk_size: u64 = 1024 * 1024 * 16;
+
+    let input = Path::new("/home/decduck/Dev/droplet-output");
+    let output = Path::new("/home/decduck/Dev/droplet-rebuilt");
+
+    let manifest_path = input.join("manifest.drop");
+    let manifest_file_handle = File::open(manifest_path).unwrap();
+
+    let manifest: Manifest = from_reader(manifest_file_handle).unwrap();
+    manifest.record.into_par_iter().for_each(|(key, value)| {
+        let file = output.join(key.clone());
+        create_dir_all(file.parent().unwrap()).unwrap();
+        let mut file_handle = File::create(file).unwrap();
+
+        #[cfg(unix)]
+        {
+            let mut file_permissions = file_handle.metadata().unwrap().permissions();
+            file_permissions.set_mode(generate_permissions(value.permissions));
+            file_handle.set_permissions(file_permissions).unwrap();
+        }
+
+        for chunk in value.chunks {
+            let chunk_path = input.join(chunk.uuid + ".bin");
+            let chunk_handle = File::open(chunk_path).unwrap();
+
+            let chunk_reader = BufReader::new(chunk_handle);
+            let mut decompressor = XzDecoder::new(chunk_reader);
+
+            let offset = u64::try_from(chunk.index).unwrap() * chunk_size;
+            file_handle.seek(io::SeekFrom::Start(offset)).unwrap();
+
+            io::copy(&mut decompressor, &mut file_handle).unwrap();
+        }
+    });
+
+    return Ok(());
+}