chore: clean up

ChoHee15 · ChoHee15 · commit 1f29e72f9c86 · 2025-09-24T23:30:57.000+08:00
Signed-off-by: chohee &lt;cc5281@126.com&gt;
diff --git a/dragonfly-client-backend/Cargo.toml b/dragonfly-client-backend/Cargo.toml
@@ -12,8 +12,7 @@ edition.workspace = true
 [dependencies]
 dragonfly-client-core.workspace = true
 dragonfly-client-util.workspace = true
-# dragonfly-api.workspace = true
-dragonfly-api = { git = "file:///codes/dragonflyoss/api_fork", branch = "for_client"}
+dragonfly-api.workspace = true
 reqwest.workspace = true
 reqwest-middleware.workspace = true
 tokio.workspace = true
diff --git a/dragonfly-client-storage/Cargo.toml b/dragonfly-client-storage/Cargo.toml
@@ -14,8 +14,7 @@ dragonfly-client-core.workspace = true
 dragonfly-client-config.workspace = true
 dragonfly-client-metric.workspace = true
 dragonfly-client-util.workspace = true
-# dragonfly-api.workspace = true
-dragonfly-api = { git = "file:///codes/dragonflyoss/api_fork", branch = "for_client"}
+dragonfly-api.workspace = true
 chrono.workspace = true
 reqwest.workspace = true
 rocksdb.workspace = true
diff --git a/dragonfly-client-storage/src/content.rs b/dragonfly-client-storage/src/content.rs
@@ -1262,7 +1262,6 @@ mod tests {
         // base64 key
         let base64_key = "jqe8buWT8rsfBMYt8mpwSbnjy44WNy/5v1gN1JfFsNk=";
         let key = base64::decode(base64_key).expect("Failed to decode base64 key");
-        println!("key: {:#x?}", key);
         
         let config = Arc::new(config);
         let content = Content::new(config, temp_dir.path(), Some(key)).await.unwrap();
@@ -1276,7 +1275,7 @@ mod tests {
 
         let data = b"data";
         
-        // cal CRC
+        // calculate CRC
         let mut plaintext_hasher = crc32fast::Hasher::new();
         plaintext_hasher.update(data);
         let plaintext_crc = plaintext_hasher.finalize();
diff --git a/dragonfly-client-storage/src/encrypt/algorithm/aes_ctr.rs b/dragonfly-client-storage/src/encrypt/algorithm/aes_ctr.rs
@@ -2,7 +2,7 @@ use aes::Aes256;
 use ctr::Ctr128BE;
 use ctr::cipher::{StreamCipher, KeyIvInit};
 use generic_array::typenum::{U16, U32};
-// use generic_array::GenericArray;
+use generic_array::GenericArray;
 
 use super::EncryptionAlgorithm;
 
@@ -12,26 +12,11 @@ impl EncryptionAlgorithm for Aes256Ctr {
     type NonceSize = U16;
     type KeySize = U32;
 
-    // fn new(key: &[u8], nonce: &[u8]) -> Self {
-    //     // if key.len() != <Self::KeySize as Unsigned>::to_usize() {
-    //     //     panic!("invalid key length");
-    //     // }
-    //     // if nonce.len() != <Self::NonceSize as Unsigned>::to_usize() {
-    //     //     panic!("invalid nonce length");
-    //     // }
-
-    //     let key_array = GenericArray::<u8, Self::KeySize>::from_slice(key);
-    //     let nonce_array = GenericArray::<u8, Self::NonceSize>::from_slice(nonce);
-
-    //     // <Ctr128BE<Aes256> as KeyIvInit>::new(key_array, nonce_array)
-    //     Self::new_from_array(key_array, nonce_array)
-    // }
-
     fn new_from_array(
-            key: &generic_array::GenericArray<u8, Self::KeySize>, 
-            nonce: &generic_array::GenericArray<u8, Self::NonceSize>
+            key: &GenericArray<u8, Self::KeySize>, 
+            nonce: &GenericArray<u8, Self::NonceSize>
         ) -> Self where Self: Sized {
-        <Ctr128BE<Aes256> as KeyIvInit>::new(key, nonce)
+        <Aes256Ctr as KeyIvInit>::new(key, nonce)
     }
 
     fn apply_keystream(&mut self, data: &mut [u8]) {
diff --git a/dragonfly-client-storage/src/encrypt/algorithm/mod.rs b/dragonfly-client-storage/src/encrypt/algorithm/mod.rs
@@ -1,38 +1,40 @@
 mod aes_ctr;
 
-use cipher::Unsigned;
 use generic_array::{GenericArray, ArrayLength};
 use hkdf::Hkdf;
 use sha2::Sha256;
 
 pub use aes_ctr::Aes256Ctr;
 
+/// EncryptionAlgorithm is a trait that defines the encryption algorithm.
 pub trait EncryptionAlgorithm {
     /// Bytes of key
     type KeySize: ArrayLength<u8>;
     /// Bytes of nonce
     type NonceSize: ArrayLength<u8>;
 
+    /// new creates a new encryption algorithm from a key and a nonce using u8 slice.
     fn new(key: &[u8], nonce: &[u8]) -> Self where Self: Sized {
         // will panic if length is not fit
         let key_array = GenericArray::<u8, Self::KeySize>::from_slice(key);
         let nonce_array = GenericArray::<u8, Self::NonceSize>::from_slice(nonce);
         Self::new_from_array(key_array, nonce_array)
     }
 
+    /// new_from_array creates a new encryption algorithm from a key and a nonce using GenericArray.
     fn new_from_array(
         key: &GenericArray<u8, Self::KeySize>, 
         nonce: &GenericArray<u8, Self::NonceSize>
     ) -> Self where Self: Sized;
 
+    /// apply_keystream applies the keystream to the data.
     fn apply_keystream(&mut self, data: &mut [u8]);
 
+    /// derive_key derives a key from a master key and a task id.
     fn derive_key(master_key: &[u8], task_id: &str) -> GenericArray<u8, Self::KeySize> {
         let hk = Hkdf::<Sha256>::new(Some(task_id.as_bytes()), master_key);
         let mut okm: GenericArray<u8, Self::KeySize> = GenericArray::default();
         hk.expand(b"task-encryption", &mut okm).unwrap();
-        assert_eq!(okm.len(), <Self::KeySize as Unsigned>::to_usize());
-        assert_eq!(okm.len(), master_key.len());
         okm
     }
 }
diff --git a/dragonfly-client-storage/src/encrypt/cryptor/reader.rs b/dragonfly-client-storage/src/encrypt/cryptor/reader.rs
@@ -7,28 +7,16 @@ use generic_array::GenericArray;
 
 use crate::encrypt::{EncryptionAlgorithm, Aes256Ctr};
 
+/// EncryptReader is a reader that encrypts the data.
 pub struct EncryptReader<R: AsyncRead, A: EncryptionAlgorithm> {
     inner: R,
     cipher: A,
 }
 
-// impl<R, A: EncryptionAlgorithm> EncryptReader<R, A> {
-//     pub fn new(inner: R, key: &[u8], piece_id: &str) -> Self {
-//         let (task_id, piece_num) = parse_piece_id(piece_id)
-//             .expect("should have task_id and piece_num");
-
-//         let nonce = A::build_nonce(task_id, piece_num);
-//         let cipher = A::new(key, &nonce);
-
-//         Self { inner, cipher }
-//     }
-// }
-
 impl<R: AsyncRead> EncryptReader<R, Aes256Ctr> {
     /// default for Aes256Ctr
     pub fn new(inner: R, key: &[u8], task_id: &str, offset: u64) -> Self {
         let key = <Aes256Ctr as EncryptionAlgorithm>::derive_key(key, task_id);
-        // let nonce = [0u8; <Aes256Ctr as EncryptionAlgorithm>::NONCE_SIZE];
         let zero_nonce = GenericArray::<u8, <Aes256Ctr as EncryptionAlgorithm>::NonceSize>::default();
 
         let mut cipher = <Aes256Ctr as EncryptionAlgorithm>::new_from_array(&key, &zero_nonce);
@@ -56,7 +44,8 @@ impl<R: AsyncRead + Unpin, A: EncryptionAlgorithm> AsyncRead for EncryptReader<R
     }
 }
 
-// same for decrypt
+/// DecryptReader is a reader that decrypts the data.
+/// As same as EncryptReader due to symmetric encryption.
 pub type DecryptReader<R, A> = EncryptReader<R, A>;
 
 #[cfg(test)]
@@ -78,7 +67,6 @@ mod tests {
 
     #[tokio::test]
     async fn test_encrypt_decrypt_cycle() {
-        // let (key, iv) = generate_key_iv();
         let key = generate_key();
 
         // Simulate input reader with AsyncCursor
diff --git a/dragonfly-client-storage/src/metadata.rs b/dragonfly-client-storage/src/metadata.rs
@@ -1169,8 +1169,6 @@ impl<E: StorageEngineOwned> Metadata<E> {
             })
             .collect::<Result<Vec<Box<[u8]>>>>()?;
 
-        info!("query for task [{}] found {} pieces", task_id, pieces.len());
-
         pieces
             .iter()
             .map(|piece| Piece::deserialize_from(piece))
diff --git a/dragonfly-client-storage/src/storage_engine/rocksdb.rs b/dragonfly-client-storage/src/storage_engine/rocksdb.rs
@@ -101,7 +101,6 @@ impl RocksdbStorageEngine {
 
         // Initialize column family options.
         let mut cf_options = rocksdb::Options::default();
-        // TODO
         cf_options.set_prefix_extractor(rocksdb::SliceTransform::create_fixed_prefix(64));
         cf_options.set_memtable_prefix_bloom_ratio(0.25);
         cf_options.optimize_level_style_compaction(Self::DEFAULT_MEMTABLE_MEMORY_BUDGET);
@@ -214,8 +213,6 @@ impl Operations for RocksdbStorageEngine {
         prefix: &[u8],
     ) -> Result<impl Iterator<Item = Result<(Box<[u8]>, Box<[u8]>)>>> {
         let cf = cf_handle::<O>(self)?;
-        // prefix should not shorter than `set_prefix_extractor`
-        // assert!(prefix.len() >= 64);
         Ok(self.prefix_iterator_cf(cf, prefix).map(|ele| {
             let (key, value) = ele.or_err(ErrorType::StorageError)?;
             Ok((key, value))
@@ -645,125 +642,4 @@ mod tests {
             assert!(format!("{:?}", err).contains("ColumnFamilyNotFound"));
         }
     }
-
-    #[test]
-    /// copied from `test_prefix_iter_raw`
-    fn test_prefix_iter_raw_shorter_key_should_fail() {
-        let engine = create_test_engine();
-
-        // RocksDB prefix extractor is configured with fixed_prefix(64) in the open method.
-        let prefix_a = [b'a'; 64];
-        let prefix_b = [b'b'; 64];
-
-
-        // ADD shorter key test
-        let prefix_a_shorter: [u8; 10] = prefix_a[..10].try_into().unwrap();
-
-        println!("prefix_a address: {:p}", &prefix_a);
-        println!("prefix_a_shorter address: {:p}", &prefix_a_shorter);
-        println!("shoter(len: {}): {:#?}",prefix_a_shorter.len(), prefix_a_shorter);
-        // ADD shorter key test
-
-        // Create test keys with 64-byte identical prefixes.
-        let key_a1 = [&prefix_a[..], b"_raw_suffix1"].concat();
-        let key_a2 = [&prefix_a[..], b"_raw_suffix2"].concat();
-
-        let key_b1 = [&prefix_b[..], b"_raw_suffix1"].concat();
-        let key_b2 = [&prefix_b[..], b"_raw_suffix2"].concat();
-
-        let objects_with_prefix_a = vec![
-            (
-                key_a1.clone(),
-                Object {
-                    id: "raw_prefix_id_a1".to_string(),
-                    value: 100,
-                },
-            ),
-            (
-                key_a2.clone(),
-                Object {
-                    id: "raw_prefix_id_a2".to_string(),
-                    value: 200,
-                },
-            ),
-        ];
-
-        let objects_with_prefix_b = vec![
-            (
-                key_b1.clone(),
-                Object {
-                    id: "raw_prefix_id_b1".to_string(),
-                    value: 300,
-                },
-            ),
-            (
-                key_b2.clone(),
-                Object {
-                    id: "raw_prefix_id_b2".to_string(),
-                    value: 400,
-                },
-            ),
-        ];
-
-        for (key, obj) in &objects_with_prefix_a {
-            engine.put::<Object>(key, obj).unwrap();
-        }
-
-        for (key, obj) in &objects_with_prefix_b {
-            engine.put::<Object>(key, obj).unwrap();
-        }
-
-        let retrieved_objects = engine
-            // .prefix_iter_raw::<Object>(&prefix_a[..10])
-            // .prefix_iter_raw::<Object>(&prefix_a)
-            .prefix_iter_raw::<Object>(&prefix_a_shorter)
-            .unwrap()
-            .collect::<Result<Vec<_>>>()
-            .unwrap();
-
-        // Can not seek value
-        assert_eq!(
-            retrieved_objects.len(),
-            objects_with_prefix_a.len(),
-            "expected {} raw objects with prefix 'a', but got {}",
-            objects_with_prefix_a.len(),
-            retrieved_objects.len()
-        );
-
-        // println!("Retrieved objects count: {}", retrieved_objects.len());
-        // for (i, (key, value)) in retrieved_objects.iter().enumerate() {
-        //     println!("Object {}: key={:?}, value_len={}", i, key, value.len());
-        //     if let Ok(obj) = Object::deserialize_from(value) {
-        //         println!("  -> deserialized: id={}, value={}", obj.id, obj.value);
-        //     } else {
-        //         println!("  -> failed to deserialize");
-        //     }
-        // }
-
-        // // Verify each object with prefix can be deserialized from raw bytes.
-        // for (_, object) in &objects_with_prefix_a {
-        //     let found = retrieved_objects
-        //         .iter()
-        //         .any(|(_, v)| match Object::deserialize_from(v) {
-        //             Ok(deserialized) => {
-        //                 deserialized.id == object.id && deserialized.value == object.value
-        //             }
-        //             Err(_) => false,
-        //         });
-
-        //     assert!(
-        //         found,
-        //         "could not find or deserialize object with key {:?}",
-        //         object.id
-        //     );
-        // }
-
-        // // Verify objects with different prefix are not retrieved.
-        // for (key, _) in &objects_with_prefix_b {
-        //     let found = retrieved_objects
-        //         .iter()
-        //         .any(|(k, _)| k.as_ref() == key.as_slice());
-        //     assert!(!found, "found object with different prefix: {:?}", key);
-        // }
-    }
 }
diff --git a/dragonfly-client-util/Cargo.toml b/dragonfly-client-util/Cargo.toml
@@ -12,6 +12,7 @@ edition.workspace = true
 [dependencies]
 dragonfly-client-core.workspace = true
 dragonfly-api.workspace = true
+reqwest.workspace = true
 http-range-header.workspace = true
 http.workspace = true
 tracing.workspace = true
diff --git a/dragonfly-client/Cargo.toml b/dragonfly-client/Cargo.toml
@@ -29,8 +29,7 @@ dragonfly-client-storage.workspace = true
 dragonfly-client-backend.workspace = true
 dragonfly-client-metric.workspace = true
 dragonfly-client-util.workspace = true
-# dragonfly-api.workspace = true
-dragonfly-api = { git = "file:///codes/dragonflyoss/api_fork", branch = "for_client"}
+dragonfly-api.workspace = true
 rcgen.workspace = true
 hyper.workspace = true
 hyper-util.workspace = true
diff --git a/dragonfly-client/src/bin/dfdaemon/main.rs b/dragonfly-client/src/bin/dfdaemon/main.rs
@@ -166,7 +166,7 @@ async fn main() -> Result<(), anyhow::Error> {
     let manager_client = Arc::new(manager_client);
 
     // Get primary key from manager, None when encryption disabled
-    let primary_key = get_key_from_manager(&config, &manager_client).await;
+    let primary_key = get_key_from_manager(&config, &manager_client).await?;
 
     // Initialize storage.
     let storage = Storage::new(
@@ -467,7 +467,11 @@ async fn main() -> Result<(), anyhow::Error> {
     Ok(())
 }
 
-async fn get_key_from_manager(config: &dfdaemon::Config, client: &ManagerClient) -> Option<Vec<u8>>{
+/// get_key_from_manager gets the primary key from the manager.
+async fn get_key_from_manager(
+    config: &dfdaemon::Config, 
+    client: &ManagerClient
+) -> Result<Option<Vec<u8>>, anyhow::Error> {
     let source_type = if config.seed_peer.enable {
         SourceType::SeedPeerSource.into()
     } else {
@@ -480,16 +484,19 @@ async fn get_key_from_manager(config: &dfdaemon::Config, client: &ManagerClient)
             hostname: config.host.hostname.clone(),
             ip: config.host.ip.unwrap().to_string(),
         }
-    ).await
-    .expect("fail to get encryption info from Manager");
+    )
+    .await
+    .inspect_err(|err| {
+        error!("fail to get encryption info from Manager: {}", err);
+    })?;
 
     if !enable {
         info!("encryption is disabled");
-        return None;
+        return Ok(None);
     }
     info!("encryption is enabled");
     let key = key.expect("should have key when manager enable encryption");
     let key_base64 = BASE64_STANDARD.encode(&key);
     debug!("key response(base64): {} \n (hex): {:x?}", key_base64, key);
-    Some(key)
+    Ok(Some(key))
 }
diff --git a/dragonfly-client/src/grpc/dfdaemon_download.rs b/dragonfly-client/src/grpc/dfdaemon_download.rs
@@ -94,7 +94,7 @@ pub struct DfdaemonDownloadServer {
     /// _shutdown_complete is used to notify the grpc server is shutdown.
     _shutdown_complete: mpsc::UnboundedSender<()>,
 
-    // manager key is the primary key fron manager, it is None when encryption disabled
+    /// manager key is the primary key from manager, it is None when encryption disabled
     primary_key: Option<Vec<u8>>,
 }
 
