[refact]: for scorpio

Signed-off-by: Han Xiaoyang <lux1an@qq.com>

Author: Ivanbeethoven

mercury/src/hash.rs

@@ -5,6 +5,7 @@
 
 use std::{fmt::Display, io};
 
+use bincode::{Encode, Decode};
 use colored::Colorize;
 use serde::{Deserialize, Serialize};
 use sha1::Digest;
@@ -28,6 +29,7 @@ use crate::internal::object::types::ObjectType;
 ///
 #[derive(
     Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Default, Deserialize, Serialize,
+    Encode, Decode
 )]
 pub struct SHA1(pub [u8; 20]);
 

mercury/src/internal/object/commit.rs

@@ -19,6 +19,7 @@ use crate::hash::SHA1;
 use crate::internal::object::signature::Signature;
 use crate::internal::object::ObjectTrait;
 use crate::internal::object::ObjectType;
+use bincode::{Decode, Encode};
 use bstr::ByteSlice;
 use callisto::git_commit;
 use callisto::mega_commit;
@@ -35,7 +36,7 @@ use serde::Serialize;
 ///   history of a repository with a single commit object at its root.
 /// - The author and committer fields contain the name, email address, timestamp and timezone.
 /// - The message field contains the commit message, which maybe include signed or DCO.
-#[derive(Eq, Debug, Clone, Serialize, Deserialize)]
+#[derive(Eq, Debug, Clone, Serialize, Deserialize, Decode, Encode)]
 #[non_exhaustive]
 pub struct Commit {
     pub id: SHA1,

mercury/src/internal/object/signature.rs

@@ -11,6 +11,7 @@
 //!
 use std::{fmt::Display, str::FromStr};
 
+use bincode::{Decode, Encode};
 use bstr::ByteSlice;
 use chrono::Offset;
 use serde::{Deserialize, Serialize};
@@ -30,7 +31,7 @@ use crate::errors::GitError;
 /// ```
 ///
 /// So, we design a `SignatureType` enum to indicate the signature type.
-#[derive(PartialEq, Eq, Debug, Clone, Serialize, Deserialize)]
+#[derive(PartialEq, Eq, Debug, Clone, Serialize, Deserialize, Decode, Encode)]
 pub enum SignatureType {
     Author,
     Committer,
@@ -75,7 +76,7 @@ impl SignatureType {
     }
 }
 
-#[derive(PartialEq, Eq, Debug, Clone, Serialize, Deserialize)]
+#[derive(PartialEq, Eq, Debug, Clone, Serialize, Deserialize,Decode,Encode)]
 pub struct Signature {
     pub signature_type: SignatureType,
     pub name: String,

mercury/src/internal/object/tree.rs

@@ -18,6 +18,7 @@ use crate::errors::GitError;
 use crate::hash::SHA1;
 use crate::internal::object::ObjectTrait;
 use crate::internal::object::ObjectType;
+use bincode::{Encode, Decode};
 use colored::Colorize;
 use encoding_rs::GBK;
 use serde::Deserialize;
@@ -28,7 +29,7 @@ use std::fmt::Display;
 /// that entry. The mode is a three-digit octal number that encodes both the permissions and the
 /// type of the object. The first digit specifies the object type, and the remaining two digits
 /// specify the file mode or permissions.
-#[derive(PartialEq, Eq, Debug, Clone, Copy, Serialize, Deserialize, Hash)]
+#[derive(PartialEq, Eq, Debug, Clone, Copy, Serialize, Deserialize, Hash, Encode, Decode)]
 pub enum TreeItemMode {
     Blob,
     BlobExecutable,
@@ -129,7 +130,7 @@ impl TreeItemMode {
 /// 100644 hello-world\0<blob object ID>
 /// 040000 data\0<tree object ID>
 /// ```
-#[derive(PartialEq, Eq, Debug, Clone, Serialize, Deserialize, Hash)]
+#[derive(PartialEq, Eq, Debug, Clone, Serialize, Deserialize, Hash, Encode, Decode)]
 pub struct TreeItem {
     pub mode: TreeItemMode,
     pub id: SHA1,
@@ -220,7 +221,7 @@ impl TreeItem {
 
 /// A tree object is a Git object that represents a directory. It contains a list of entries, one
 /// for each file or directory in the tree.
-#[derive(Eq, Debug, Clone, Serialize, Deserialize)]
+#[derive(Eq, Debug, Clone, Serialize, Deserialize, Encode, Decode)]
 #[non_exhaustive]
 pub struct Tree {
     pub id: SHA1,

scorpio/Cargo.toml

@@ -28,7 +28,7 @@ once_cell = "1.19.0"
 arc-swap = "1.7.1"
 env_logger = "0.11.5"
 sled = "0.34.7"
-bincode = "2.0.1"
+bincode = { workspace = true , features = ["serde"] }
 async-recursion = "1.1.1"
 bytes = "1.7.2"
 futures = "0.3.31"

scorpio/src/dicfuse/tree_store.rs

@@ -1,4 +1,5 @@
 use crate::util::{config, GPath};
+use bincode::{Decode, Encode};
 use rfuse3::raw::reply::ReplyEntry;
 use rfuse3::FileType;
 use serde::{Deserialize, Serialize};
@@ -14,7 +15,7 @@ pub struct TreeStorage {
     db: Db,
 }
 
-#[derive(Serialize, Deserialize, Clone)]
+#[derive(Serialize, Deserialize, Clone,Encode,Decode)]
 pub struct StorageItem {
     inode: u64,
     parent: u64,
@@ -80,12 +81,12 @@ impl TreeStorage {
             children: Vec::new(),
             hash: item.hash,
         };
-
+        let config = bincode::config::standard();
         // Insert an item into db and update the parent item's children list.
         self.db
             .insert(
                 inode.to_be_bytes(),
-                bincode::serialize(&storage_item).map_err(Error::other)?,
+                bincode::encode_to_vec(&storage_item,config).map_err(Error::other)?,
             )
             .map_err(Error::other)?;
 
@@ -97,7 +98,7 @@ impl TreeStorage {
             self.db
                 .insert(
                     parent.to_be_bytes(),
-                    bincode::serialize(&parent_item).map_err(Error::other)?,
+                    bincode::encode_to_vec(&parent_item,config).map_err(Error::other)?,
                 )
                 .map_err(Error::other)?;
         }
@@ -122,10 +123,12 @@ impl TreeStorage {
             if storage_item.parent != 0 {
                 let mut parent_item: StorageItem = self.get_storage_item(storage_item.parent)?;
                 parent_item.children.retain(|&x| x != inode);
+                let config = bincode::config::standard();
+
                 self.db
                     .insert(
                         storage_item.parent.to_be_bytes(),
-                        bincode::serialize(&parent_item).map_err(Error::other)?,
+                       bincode::encode_to_vec(&parent_item, config).map_err(Error::other)?,
                     )
                     .map_err(Error::other)?;
             }
@@ -140,10 +143,11 @@ impl TreeStorage {
     pub fn append_child(&self, parent: u64, inode: u64) -> io::Result<()> {
         let mut st = self.get_storage_item(parent)?;
         st.children.push(inode);
+        let config = bincode::config::standard();
         self.db
             .insert(
                 parent.to_be_bytes(),
-                bincode::serialize(&st).map_err(Error::other)?,
+                bincode::encode_to_vec(&st, config).map_err(Error::other)?,
             )
             .map_err(Error::other)?;
         Ok(())
@@ -163,7 +167,8 @@ impl TreeStorage {
     pub fn get_storage_item(&self, inode: u64) -> io::Result<StorageItem> {
         match self.db.get(inode.to_be_bytes())? {
             Some(value) => {
-                let item: StorageItem = bincode::deserialize(&value).map_err(Error::other)?;
+                let config = bincode::config::standard();
+                let (item ,_) = bincode::decode_from_slice(&value,config).map_err(Error::other)?;
                 Ok(item)
             }
             None => Err(Error::new(ErrorKind::NotFound, "Item not found")),
@@ -184,10 +189,11 @@ impl TreeStorage {
     pub fn update_item_hash(&self, inode: u64, hash: String) -> io::Result<()> {
         let mut item = self.get_storage_item(inode)?;
         item.hash = hash;
+        let config = bincode::config::standard();
         self.db
             .insert(
                 inode.to_be_bytes(),
-                bincode::serialize(&item).map_err(Error::other)?,
+                bincode::encode_to_vec(&item,config).map_err(Error::other)?,
             )
             .map_err(Error::other)?;
         Ok(())

scorpio/src/manager/commit.rs

@@ -108,7 +108,7 @@ fn build_new_tree_map(
                         Err(_) => {
                             #[cfg(debug_assertions)]
                             color_info!("New Tree: \x1b[1;32m{}\x1b[0m", parent_path.display());
-                            Tree::from_tree_items(vec![])
+                            Tree::from_tree_items(vec![]).unwrap()
                         }
                     };
                     // Update the new TreeItem
@@ -274,10 +274,11 @@ pub fn commit_core(
     // overwrite operation, we can update it
     // with confidence.
     let mut batch = sled::Batch::default();
+    let config = bincode::config::standard();
     for (path, tree) in hashmap.iter() {
         batch.insert(
             path.to_string_lossy().into_owned().as_str(),
-            bincode::serialize(tree).unwrap(),
+            bincode::encode_to_vec(tree,config).unwrap(),
         );
     }
     new_tree_db.apply_batch(batch)?;

scorpio/src/manager/diff.rs

@@ -93,7 +93,7 @@ pub fn diff(
                     // just compute the NEW hash first.
                     let content = std::fs::read(&node)?;
                     item.id = SHA1::from_type_and_data(ObjectType::Blob, &content);
-                    blobs.push(Blob::from_content(content));
+                    blobs.push(Blob::from_content_bytes(content));
                 }
                 break;
             }
@@ -118,7 +118,7 @@ pub fn diff(
             } else {
                 //is a file.
                 let content = std::fs::read(&node)?;
-                let b = Blob::from_content(content);
+                let b = Blob::from_content_bytes(content);
                 t.tree_items.push(TreeItem {
                     mode: TreeItemMode::Blob,
                     id: b.id,
@@ -147,10 +147,7 @@ pub fn change(
     } else {
         // there is a new dictionary.
         println!("new tree:{tree_path:?}");
-        tree = Tree {
-            id: SHA1::default(),
-            tree_items: vec![],
-        };
+        tree = Tree::from_tree_items(vec![]).unwrap();
     }
 
     let entries = std::fs::read_dir(real_path).unwrap();
@@ -185,7 +182,7 @@ pub fn change(
                     println!("change: changed file {}", item.name);
                     let content = std::fs::read(&path).unwrap();
 
-                    let b = Blob::from_content(content);
+                    let b = Blob::from_content_bytes(content);
                     item.id = b.id; // change file hash .
                     blobs.push(b);   
                 }
@@ -211,7 +208,7 @@ pub fn change(
             } else {
                 println!("change: new file  {name}");
                 let content = std::fs::read(&path).unwrap();
-                let b = Blob::from_content(content);
+                let b = Blob::from_content_bytes(content);
                 tree.tree_items.push(TreeItem {
                     mode: TreeItemMode::Blob,
                     id: b.id,

scorpio/src/manager/fetch.rs

@@ -4,7 +4,6 @@ use crate::scolfs;
 use crate::util::config;
 use crate::util::GPath;
 use async_recursion::async_recursion;
-use axum::async_trait;
 use ceres::model::git::LatestCommitInfo;
 use crossbeam::queue::SegQueue;
 use futures::future::join_all;
@@ -351,8 +350,9 @@ pub async fn download_mr_files(
 
     Ok(())
 }
-#[allow(unused)]
-#[async_trait]
+
+
+#[allow(async_fn_in_trait)]
 pub trait CheckHash {
     async fn check(&mut self);
 
@@ -363,7 +363,7 @@ pub trait CheckHash {
     ) -> WorkDir;
 }
 
-#[async_trait]
+
 impl CheckHash for ScorpioManager {
     async fn check(&mut self) {
         let mut handlers = Vec::new();