feat: improve nrc assets source speed check

Author: copyandexecute

src-tauri/src/minecraft/downloads/norisk_assets_download.rs

@@ -9,7 +9,7 @@ use crate::state::profile_state::Profile;
 use crate::state::State;
 use futures::stream::{iter, StreamExt};
 use log::{debug, error, info, trace, warn};
-use std::collections::HashSet;
+use std::collections::{HashMap, HashSet};
 use std::path::{Path, PathBuf};
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::Arc;
@@ -236,12 +236,12 @@ impl NoriskClientAssetsDownloadService {
             )
             .await?;
 
-            match self
+            match measure_time!("NRC cleanup", self
                 .cleanup_orphan_assets(&target_base_dir, &all_expected_target_paths)
-                .await
+                .await)
             {
                 Ok(deleted_count) => info!(
-                    "[NRC Assets Cleanup] Successfully cleaned up {} orphan items.",
+                    "[NRC Assets Cleanup] Cleaned up {} orphan items",
                     deleted_count
                 ),
                 Err(e) => {
@@ -304,8 +304,8 @@ impl NoriskClientAssetsDownloadService {
         .await?;
 
         let assets =
-            match NoRiskApi::norisk_assets(asset_id, norisk_token, request_uuid, is_experimental)
-                .await
+            match measure_time!(format!("NRC API call '{}'", asset_id), NoRiskApi::norisk_assets(asset_id, norisk_token, request_uuid, is_experimental)
+                .await)
             {
                 Ok(fetched_assets) => {
                     info!(
@@ -397,20 +397,17 @@ impl NoriskClientAssetsDownloadService {
         )
         .await?;
 
-        match self
+        match measure_time!(format!("NRC download '{}'", asset_id), self
             .download_nrc_assets(
                 asset_id,
                 &assets,
                 is_experimental,
                 norisk_token,
                 Some(profile_id),
             )
-            .await
+            .await)
         {
-            Ok(_) => info!(
-                "[NRC Assets Group '{}'] Successfully downloaded assets.",
-                asset_id
-            ),
+            Ok(_) => {},
             Err(e) => {
                 error!(
                     "[NRC Assets Group '{}'] Failed to download assets: {}. Skipping copy.",
@@ -431,7 +428,7 @@ impl NoriskClientAssetsDownloadService {
         .await?;
 
         // Pass target_base_dir to copy function
-        match self
+        match measure_time!(format!("NRC copy '{}'", asset_id), self
             .copy_assets_to_game_dir(
                 asset_id,
                 &assets,
@@ -440,12 +437,9 @@ impl NoriskClientAssetsDownloadService {
                 game_directory,
                 Some(profile_id),
             )
-            .await
+            .await)
         {
-            Ok(_) => info!(
-                "[NRC Assets Group '{}'] Successfully copied assets.",
-                asset_id
-            ),
+            Ok(_) => {},
             Err(e) => {
                 error!(
                     "[NRC Assets Group '{}'] Failed to copy assets: {}. Skipping cleanup for this group's contribution.",
@@ -512,31 +506,34 @@ impl NoriskClientAssetsDownloadService {
         let mut job_count = 0;
 
         let state = if profile_id.is_some() {
-            State::get().await.ok() // Change to ok() to allow optional state
+            State::get().await.ok()
         } else {
             None
         };
-        // Clone state before the closure so the original `state` remains available after the loop
         let state_clone_for_inspect = state.clone();
 
+        // Pre-scan existing objects to avoid per-file fs::try_exists calls
+        let objects_dir = assets_path.join("objects");
+        let existing_objects = measure_time!(format!("NRC objects scan '{}'", asset_id), {
+            Self::scan_objects_dir(&objects_dir).await
+        });
+
         for (name, asset) in assets_list {
             let hash = asset.hash.clone();
             let size = asset.size;
-            
-            // Store assets by hash like Mojang: objects/ab/abcdef123...
-            let hash_prefix = &hash[0..2]; // First 2 chars
-            let objects_dir = assets_path.join("objects").join(hash_prefix);
-            let target_path = objects_dir.join(&hash);
-            
+
+            let hash_prefix = &hash[0..2];
+            let target_path = objects_dir.join(hash_prefix).join(&hash);
+
             let name_clone = name.clone();
             let task_counter_clone = Arc::clone(&task_counter);
             let completed_counter_clone = Arc::clone(&completed_counter);
             let total_to_download_clone = Arc::clone(&total_to_download);
             let asset_id_clone = asset_id.to_string();
             let norisk_token_clone = norisk_token.to_string();
 
-            // Hash-based check - if hash file exists, content is guaranteed correct
-            if fs::try_exists(&target_path).await? {
+            // Fast in-memory check instead of filesystem call
+            if existing_objects.contains_key(&hash) {
                 trace!(
                     "[NRC Assets Download '{}'] Skipping asset {} (hash {} already exists)",
                     asset_id_clone,
@@ -734,6 +731,38 @@ impl NoriskClientAssetsDownloadService {
         }
     }
 
+    /// Scans an objects directory (objects/xx/hash) and returns a HashMap of hash -> file size.
+    async fn scan_objects_dir(objects_path: &Path) -> HashMap<String, u64> {
+        let mut existing = HashMap::new();
+
+        let mut prefix_dirs = match fs::read_dir(objects_path).await {
+            Ok(dir) => dir,
+            Err(_) => return existing,
+        };
+
+        while let Ok(Some(prefix_entry)) = prefix_dirs.next_entry().await {
+            if !prefix_entry.path().is_dir() {
+                continue;
+            }
+
+            let mut hash_files = match fs::read_dir(prefix_entry.path()).await {
+                Ok(dir) => dir,
+                Err(_) => continue,
+            };
+
+            while let Ok(Some(hash_entry)) = hash_files.next_entry().await {
+                if let Ok(metadata) = hash_entry.metadata().await {
+                    if metadata.is_file() {
+                        let file_name = hash_entry.file_name().to_string_lossy().to_string();
+                        existing.insert(file_name, metadata.len());
+                    }
+                }
+            }
+        }
+
+        existing
+    }
+
     /// Helper method to emit progress events
     async fn emit_progress_event(
         &self,
@@ -821,6 +850,12 @@ impl NoriskClientAssetsDownloadService {
             .await?;
         }
 
+        // Pre-scan source objects to avoid per-file fs::try_exists + fs::metadata calls
+        let source_objects_dir = source_dir.join("objects");
+        let source_cache = measure_time!(format!("NRC copy source scan '{}'", asset_id), {
+            Self::scan_objects_dir(&source_objects_dir).await
+        });
+
         let batch_size = 50;
         let mut batch_count = 0;
         let total_batches = (total_assets + batch_size - 1) / batch_size;
@@ -832,92 +867,52 @@ impl NoriskClientAssetsDownloadService {
 
             for (name, asset) in chunk {
                 let hash = &asset.hash;
-                
-                // Source is now hash-based: objects/ab/abcdef123...
-                let hash_prefix = &hash[0..2];
-                let source_path = source_dir.join("objects").join(hash_prefix).join(hash);
 
                 // Special handling for override assets
                 let (target_path, is_override) = if name.starts_with("overrides/") {
-                    // For overrides, copy to Minecraft directory and strip the "overrides/" prefix
                     let relative_path = name.strip_prefix("overrides/").unwrap_or(name);
                     (minecraft_dir.join(relative_path), true)
                 } else {
-                    // Normal assets go to the target base directory
                     (target_base_dir.join(&name), false)
                 };
 
-                if !fs::try_exists(&source_path).await? {
-                    warn!(
-                        "[NRC Assets Copy '{}'] Hash file missing: {} (for asset {})",
-                        asset_id,
-                        source_path.display(),
-                        name
-                    );
-                    continue;
-                }
+                // Fast in-memory source check instead of fs::try_exists + fs::metadata
+                let source_size = match source_cache.get(hash.as_str()) {
+                    Some(&size) => size,
+                    None => {
+                        warn!(
+                            "[NRC Assets Copy '{}'] Hash file missing in cache for asset {} (hash {})",
+                            asset_id, name, hash
+                        );
+                        continue;
+                    }
+                };
 
                 let needs_copy = if fs::try_exists(&target_path).await? {
                     if is_override {
-                        // For override files, skip if the file already exists
-                        debug!(
-                            "[NRC Assets Copy '{}'] Skipping override file {} (already exists)",
-                            asset_id, name
-                        );
                         false
                     } else if keep_local_assets {
-                        debug!(
-                            "[NRC Assets Copy '{}'] Keeping local asset {} (keep_local_assets)",
-                            asset_id, name
-                        );
                         false
                     } else {
-                        // Hash-based system: check size first, then modification time
-                        let source_metadata = fs::metadata(&source_path).await?;
+                        // Compare target size against cached source size
                         let target_metadata = fs::metadata(&target_path).await?;
-                        
-                        if target_metadata.len() as i64 != asset.size {
+                        if target_metadata.len() != source_size {
                             debug!(
-                                "[NRC Assets Copy '{}'] Target size mismatch for {} (hash {}), needs copy",
-                                asset_id, name, hash
+                                "[NRC Assets Copy '{}'] Size mismatch for {}: target={}b, source={}b",
+                                asset_id, name, target_metadata.len(), source_size
                             );
                             true
                         } else {
-                            // Same size - check if hash file (source) is newer than target
-                            let source_modified = source_metadata.modified().unwrap_or(std::time::UNIX_EPOCH);
-                            let target_modified = target_metadata.modified().unwrap_or(std::time::UNIX_EPOCH);
-                            
-                            if source_modified > target_modified {
-                                debug!(
-                                    "[NRC Assets Copy '{}'] Hash file {} is newer than target, needs copy",
-                                    asset_id, name
-                                );
-                                true
-                            } else {
-                                trace!(
-                                    "[NRC Assets Copy '{}'] Skipping {} (hash {}), target is up to date",
-                                    asset_id, name, hash
-                                );
-                                false
-                            }
+                            false
                         }
                     }
                 } else {
-                    if is_override {
-                        debug!(
-                            "[NRC Assets Copy '{}'] Override file doesn't exist for {} (hash {}), copying to Minecraft dir",
-                            asset_id, name, hash
-                        );
-                    } else {
-                        debug!(
-                            "[NRC Assets Copy '{}'] Target doesn't exist for {} (hash {}), needs copy",
-                            asset_id, name, hash
-                        );
-                    }
                     true
                 };
 
                 if needs_copy {
+                    let hash_prefix = &hash[0..2];
+                    let source_path = source_objects_dir.join(hash_prefix).join(hash);
                     if let Some(parent) = target_path.parent() {
                         if !fs::try_exists(parent).await? {
                             fs::create_dir_all(parent).await?;