complete MR layer creation (#1233)

Author: yyjeqhc

jupiter/src/service/mod.rs

@@ -2,4 +2,3 @@
 
 pub mod issue_service;
 pub mod mr_service;
-

libra/src/command/commit.rs

@@ -58,14 +58,14 @@ pub async fn execute(args: CommitArgs) {
         let user_email = UserConfig::get("user", None, "email")
             .await
             .unwrap_or_else(|| "unknown".to_string());
-        
+
         // get sign line
         let signoff_line = format!("Signed-off-by: {user_name} <{user_email}>");
         format!("{}\n\n{signoff_line}", args.message)
     } else {
         args.message.clone()
     };
-    
+
     // check format(if needed)
     if args.conventional && !check_conventional_commits_message(&commit_message) {
         panic!("fatal: commit message does not follow conventional commits");
@@ -270,11 +270,10 @@ mod test {
         let args = args.unwrap();
         assert!(args.amend);
         assert!(args.signoff);
-
     }
 
     #[tokio::test]
-    #[serial] 
+    #[serial]
     /// Tests the recursive tree creation from index entries.
     /// Verifies that tree objects are correctly created, saved to storage, and properly organized in a hierarchical structure.
     async fn test_create_tree() {

libra/tests/command/log_test.rs

@@ -132,32 +132,32 @@ async fn test_log_oneline() {
     let temp_path = tempdir().unwrap();
     test::setup_with_new_libra_in(temp_path.path()).await;
     let _guard = ChangeDirGuard::new(temp_path.path());
-    
+
     // Create test commits
     let commit_id = create_test_commit_tree().await;
     let reachable_commits = get_reachable_commits(commit_id).await;
-    
+
     // Test oneline format
-    let args = LogArgs { 
-        number: Some(3), 
-        oneline: true 
+    let args = LogArgs {
+        number: Some(3),
+        oneline: true,
     };
-    
+
     // Since execute function writes to stdout, we'll test the logic directly
     let mut sorted_commits = reachable_commits.clone();
     sorted_commits.sort_by(|a, b| b.committer.timestamp.cmp(&a.committer.timestamp));
-    
+
     let max_commits = std::cmp::min(args.number.unwrap_or(usize::MAX), sorted_commits.len());
-    
+
     for (i, commit) in sorted_commits.iter().take(max_commits).enumerate() {
         // Test short hash format (should be 7 characters)
         let short_hash = &commit.id.to_string()[..7];
         assert_eq!(short_hash.len(), 7);
-        
+
         // Test that commit message parsing works
         let (msg, _) = common::utils::parse_commit_msg(&commit.message);
         assert!(!msg.is_empty());
-        
+
         // For our test commits, verify the expected format
         let expected_number = 6 - i; // commits are numbered 6, 5, 4, 3, 2, 1
         assert_eq!(msg.trim(), format!("Commit_{expected_number}"));

mercury/src/internal/model/commit.rs

@@ -1,16 +1,11 @@
-
-
 use callisto::{git_commit, mega_commit};
 use common::utils::generate_id;
 
-use crate::{
-    internal::{
-        object::{commit::Commit, ObjectTrait},
-        pack::entry::Entry,
-    },
+use crate::internal::{
+    object::{commit::Commit, ObjectTrait},
+    pack::entry::Entry,
 };
 
-
 impl From<Commit> for mega_commit::Model {
     fn from(value: Commit) -> Self {
         mega_commit::Model {

mercury/src/internal/object/blob.rs

@@ -82,7 +82,6 @@ impl ObjectTrait for Blob {
 }
 
 impl Blob {
-
     /// Create a new Blob object from the given content string.
     /// - This is a convenience method for creating a Blob from a string.
     /// - It converts the string to bytes and then calls `from_content_bytes`.

mercury/src/internal/object/commit.rs

@@ -51,8 +51,6 @@ impl PartialEq for Commit {
     }
 }
 
-
-
 impl Display for Commit {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         writeln!(f, "tree: {}", self.tree_id)?;
@@ -279,4 +277,4 @@ impl From<git_commit::Model> for Commit {
             value.content,
         )
     }
-}
+}

mercury/src/internal/pack/encode.rs

@@ -573,7 +573,7 @@ mod tests {
         println!("{data:?}");
         let mut reader = Cursor::new(data);
         let (result, _) = read_offset_encoding(&mut reader).unwrap();
-        println!("result: {result}" );
+        println!("result: {result}");
         assert_eq!(result, value as u64);
     }
 }

scorpio/src/daemon/mod.rs

@@ -154,7 +154,7 @@ async fn mount_handler(
         };
 
         let store_path = PathBuf::from(store_path).join(&temp_hash);
-        let _ = state.fuse.overlay_mount(inode, store_path,false).await;
+        let _ = state.fuse.overlay_mount(inode, store_path, false).await;
         let mount_info = MountInfo {
             hash: temp_hash.clone(),
             path: mono_path.clone(),
@@ -174,10 +174,15 @@ async fn mount_handler(
     }
 
     if let Some(m) = &req.mr {
-
+        let mr_store_path = PathBuf::from(store_path).join("mr");
         // if mr is provided, we need to fetch the mr info from mono.
-        mr::build_mr_layer(m, store_path.into()).await.unwrap();
-    
+        if let Err(e) = mr::build_mr_layer(m, mr_store_path).await {
+            return axum::Json(MountResponse {
+                status: FAIL.into(),
+                mount: MountInfo::default(),
+                message: format!("Failed to build mr layer: {e}"),
+            });
+        }
     }
 
     // fetch the dionary node info from mono.
@@ -186,7 +191,10 @@ async fn mount_handler(
     let store_path = PathBuf::from(store_path).join(&work_dir.hash);
     // checkout / mount this dictionary.
 
-    let _ = state.fuse.overlay_mount(inode, store_path,false).await;
+    let _ = state
+        .fuse
+        .overlay_mount(inode, store_path, req.mr.is_some())
+        .await;
 
     let mount_info = MountInfo {
         hash: work_dir.hash,

scorpio/src/fuse/mod.rs

@@ -70,7 +70,10 @@ impl MegaFuse {
         // mount user works.
         for dir in &manager.works {
             let _lower = PathBuf::from(store_path).join(&dir.hash);
-            megafuse.overlay_mount(dir.node, &_lower,false).await.unwrap();
+            megafuse
+                .overlay_mount(dir.node, &_lower, false)
+                .await
+                .unwrap();
         }
 
         megafuse
@@ -92,7 +95,7 @@ impl MegaFuse {
         &self,
         inode: u64,
         store_path: P,
-        need_mr:bool, // if need mr, then create mr layer.
+        need_mr: bool, // if need mr, then create mr layer.
     ) -> std::io::Result<()> {
         let lower = store_path.as_ref().join("lower");
         let upper = store_path.as_ref().join("upper");
@@ -151,8 +154,6 @@ impl MegaFuse {
         Ok(())
     }
 
-   
-
     /// Unmounts the overlay filesystem associated with a given inode asynchronously.
     ///
     /// This function removes the overlay filesystem mapped to the specified inode from

scorpio/src/manager/fetch.rs

@@ -328,6 +328,29 @@ pub fn enqueue_file_download(file_id: SHA1, save_path: PathBuf) {
     }
 }
 
+/// Download multiple files for MR scenarios.
+pub async fn download_mr_files(
+    files: Vec<(SHA1, PathBuf)>,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let download_manager = DownloadManager::get_global();
+
+    // Since this is for MR files only (no directory traversal),
+    // we mark directory processing as complete immediately
+    download_manager.notify_directory_processing_complete();
+
+    // Enqueue all file download tasks
+    for (file_id, save_path) in files {
+        let task = DownloadTask::new(file_id, save_path);
+        if let Err(e) = download_manager.enqueue_download(task) {
+            return Err(format!("Failed to enqueue download task for file {file_id}: {e}").into());
+        }
+    }
+
+    // Wait for all downloads to complete
+    download_manager.wait_for_completion().await;
+
+    Ok(())
+}
 #[allow(unused)]
 #[async_trait]
 pub trait CheckHash {