feat: optimize implement of the vortex (#19)

Author: gaius-qi

README.md

@@ -5,15 +5,17 @@
 
 ## Introduction
 
-Vortex is a high-performance peer-to-peer (P2P) file transfer protocol implementation in Rust, designed as part of the Dragonfly project. It utilizes the TLV (Tag-Length-Value) format for efficient and flexible data transmission, making it ideal for large-scale file distribution scenarios.
+Vortex is a high-performance peer-to-peer (P2P) file transfer protocol implementation in Rust,
+designed as part of the Dragonfly project. It utilizes the TLV (Tag-Length-Value) format for
+efficient and flexible data transmission, making it ideal for large-scale file distribution scenarios.
 
-### Key Features
+### Features
 
-- **Efficient TLV Protocol**: Optimized for fast serialization and deserialization of data packets
-- **Large File Support**: Handles piece sizes up to 1 GiB and value fields up to 4 GiB
-- **Memory Safety**: Built in Rust with zero-cost abstractions and memory safety guarantees
-- **High Performance**: Designed for high-throughput file transfer scenarios
-- **Extensible Design**: Reserved tags for future protocol extensions like compression and encryption
+- **Efficient TLV Protocol**: Optimized for fast serialization and deserialization of data packets.
+- **Large File Support**: Handles piece sizes up to 1 GiB and value fields up to 4 GiB.
+- **Memory Safety**: Built in Rust with zero-cost abstractions and memory safety guarantees.
+- **High Performance**: Designed for high-throughput file transfer scenarios.
+- **Extensible Design**: Reserved tags for future protocol extensions like compression and encryption.
 
 ## Documentation
 
@@ -37,7 +39,3 @@ The benchmarks cover various packet sizes:
 - Medium packets (1 KB)
 - Large packets (1 MB)
 - Extra large packets (16 MB)
-
-## LICENSE
-
-Apache 2.0 License. Please see [LICENSE](LICENSE) for more information.

src/lib.rs

@@ -76,6 +76,7 @@ impl Vortex {
             tag,
             length: value.len(),
         };
+
         (tag, header, value).try_into()
     }
 
@@ -173,8 +174,11 @@ impl Vortex {
     }
 }
 
+/// Implement TryFrom<(tlv::Tag, Header, Bytes)> for Vortex.
 impl TryFrom<(tlv::Tag, Header, Bytes)> for Vortex {
     type Error = Error;
+
+    /// try_from converts a tuple of Tag, Header, and Bytes into a Vortex packet.
     fn try_from((tag, header, value): (tlv::Tag, Header, Bytes)) -> Result<Self> {
         match tag {
             tlv::Tag::DownloadPiece => {
@@ -216,6 +220,7 @@ mod tests {
         let value = b"piece content";
         let packet = Vortex::new(Tag::PieceContent, Bytes::from_static(value))
             .expect("Failed to create packet");
+
         assert_eq!(packet.tag(), &Tag::PieceContent);
         assert_eq!(packet.length(), value.len());
     }
@@ -227,6 +232,7 @@ mod tests {
             .expect("Failed to create packet");
         let bytes = packet.to_bytes();
         let deserialized = Vortex::from_bytes(bytes).expect("Failed to deserialize packet");
+
         assert_eq!(packet.tag(), deserialized.tag());
         assert_eq!(packet.length(), deserialized.length());
     }
@@ -237,14 +243,15 @@ mod tests {
         let packet = Vortex::new(Tag::PieceContent, Bytes::from_static(value))
             .expect("Failed to create packet");
         let bytes = packet.to_bytes();
+
         assert_eq!(bytes.len(), HEADER_SIZE + value.len());
     }
 
     #[test]
     fn test_error_handling() {
-        // Test invalid length
         let value = vec![0; MAX_VALUE_SIZE + 1];
         let result = Vortex::new(Tag::PieceContent, value.into());
+
         assert!(matches!(result, Err(Error::InvalidLength(_))));
     }
 }

src/tlv/download_piece.rs

@@ -75,10 +75,11 @@ impl DownloadPiece {
     }
 }
 
-/// Implement TryFrom<Bytes> for DownloadPiece.
+/// Implement TryFrom<Bytes> for DownloadPiece for conversion from a byte slice.
 impl TryFrom<Bytes> for DownloadPiece {
     type Error = Error;
 
+    /// try_from decodes the download piece request from the byte slice.
     fn try_from(bytes: Bytes) -> Result<Self> {
         let mut parts = bytes.splitn(2, |&b| b == SEPARATOR);
         let task_id = std::str::from_utf8(
@@ -103,8 +104,9 @@ impl TryFrom<Bytes> for DownloadPiece {
     }
 }
 
-/// Implement From<DownloadPiece> for Bytes.
+/// Implement From<DownloadPiece> for Bytes for conversion to a byte slice.
 impl From<DownloadPiece> for Bytes {
+    /// from converts the download piece request to a byte slice.
     fn from(piece: DownloadPiece) -> Self {
         let mut bytes = BytesMut::with_capacity(DOWNLOAD_PIECE_SIZE);
         bytes.extend_from_slice(piece.task_id.as_bytes());
@@ -145,31 +147,28 @@ mod tests {
         let piece_number = 42;
         let download_piece = DownloadPiece::new(task_id.clone(), piece_number);
 
-        // Test From<DownloadPiece> for Bytes
         let bytes: Bytes = download_piece.into();
+        let download_piece = DownloadPiece::try_from(bytes).unwrap();
 
-        // Test TryFrom<Bytes> for DownloadPiece
-        let download_piece_decoded = DownloadPiece::try_from(bytes).unwrap();
-
-        assert_eq!(download_piece_decoded.task_id(), task_id);
-        assert_eq!(download_piece_decoded.piece_number(), piece_number);
+        assert_eq!(download_piece.task_id(), task_id);
+        assert_eq!(download_piece.piece_number(), piece_number);
     }
 
     #[test]
     fn test_invalid_conversion() {
-        // Test missing separator
+        // Test missing separator.
         let invalid_bytes = Bytes::from("invalid_input_without_separator");
         let result = DownloadPiece::try_from(invalid_bytes);
         assert!(result.is_err());
         assert!(matches!(result.unwrap_err(), Error::InvalidPacket(_)));
 
-        // Test missing piece number
+        // Test missing piece number.
         let invalid_bytes = Bytes::from("task_id-");
         let result = DownloadPiece::try_from(invalid_bytes);
         assert!(result.is_err());
         assert!(matches!(result.unwrap_err(), Error::ParseIntError(_)));
 
-        // Test invalid piece number
+        // Test invalid piece number.
         let invalid_bytes = Bytes::from("task_id-invalid");
         let result = DownloadPiece::try_from(invalid_bytes);
         assert!(result.is_err());

src/tlv/error.rs

@@ -118,8 +118,9 @@ impl Error {
     }
 }
 
+/// Implement From<Error> for Bytes.
 impl From<Error> for Bytes {
-    // Converts a Error request to a byte slice.
+    /// from converts the error request to a byte slice.
     fn from(err: Error) -> Self {
         let mut bytes = BytesMut::with_capacity(err.len());
         bytes.put_u8(err.code.into());
@@ -129,9 +130,11 @@ impl From<Error> for Bytes {
     }
 }
 
+/// Implement TryFrom<Bytes> for Error.
 impl TryFrom<Bytes> for Error {
     type Error = VortexError;
 
+    /// try_from decodes the error request from the byte slice.
     fn try_from(bytes: Bytes) -> VortexResult<Self> {
         let mut parts = bytes.splitn(2, |&b| b == SEPARATOR);
 
@@ -194,23 +197,23 @@ mod tests {
         let error = Error::new(code, message.clone());
 
         let bytes: Bytes = error.into();
-        let error_decoded = Error::try_from(bytes).unwrap();
+        let error = Error::try_from(bytes).unwrap();
 
-        assert_eq!(error_decoded.code(), code);
-        assert_eq!(error_decoded.message(), message);
+        assert_eq!(error.code(), code);
+        assert_eq!(error.message(), message);
     }
 
     #[test]
     fn test_from_bytes_invalid_input() {
-        // Test missing separator
+        // Test missing separator.
         let invalid_bytes = Bytes::from("invalid_input_without_separator");
         assert!(Error::try_from(invalid_bytes).is_err());
 
-        // Test missing error message
+        // Test missing error message.
         let invalid_bytes = Bytes::from(format!("{}:", 1));
         assert!(Error::try_from(invalid_bytes).is_err());
 
-        // Test invalid error code format
+        // Test invalid error code format.
         let invalid_bytes = Bytes::from(format!("{}:{}", 256, "Invalid code"));
         assert!(Error::try_from(invalid_bytes).is_err());
     }

src/tlv/piece_content.rs

@@ -15,12 +15,10 @@
  */
 
 use crate::error::{Error, Result};
+use crate::MAX_VALUE_SIZE;
 use bytes::Bytes;
 use std::convert::TryFrom;
 
-/// MAX_PIECE_SIZE is the maximum size of a piece content (4 GiB).
-const MAX_PIECE_SIZE: usize = crate::MAX_VALUE_SIZE;
-
 /// PieceContent represents the content of a piece.
 #[derive(Debug, Clone)]
 pub struct PieceContent(Bytes);
@@ -30,11 +28,11 @@ impl PieceContent {
     /// new creates a new piece content.
     pub fn new(content: Bytes) -> Result<Self> {
         // Check content length
-        if content.len() > MAX_PIECE_SIZE {
+        if content.len() > MAX_VALUE_SIZE {
             return Err(Error::InvalidLength(format!(
                 "content length {} exceeds maximum size {}",
                 content.len(),
-                MAX_PIECE_SIZE
+                MAX_VALUE_SIZE
             )));
         }
 
@@ -56,13 +54,15 @@ impl PieceContent {
 impl TryFrom<Bytes> for PieceContent {
     type Error = Error;
 
+    /// try_from converts Bytes to PieceContent.
     fn try_from(bytes: Bytes) -> Result<Self> {
         Self::new(bytes)
     }
 }
 
 /// Implement From<PieceContent> for Bytes.
 impl From<PieceContent> for Bytes {
+    /// from converts PieceContent to Bytes.
     fn from(piece: PieceContent) -> Self {
         piece.0
     }
@@ -76,6 +76,7 @@ mod tests {
     fn test_new() {
         let content = vec![1, 2, 3, 4];
         let result = PieceContent::new(content.into());
+
         assert!(result.is_ok());
         assert_eq!(result.unwrap().len(), 4);
     }
@@ -84,6 +85,7 @@ mod tests {
     fn test_is_empty() {
         let content = Bytes::new();
         let result = PieceContent::new(content);
+
         assert!(result.is_ok());
         assert!(result.unwrap().is_empty());
     }
@@ -93,21 +95,16 @@ mod tests {
         let content = vec![1, 2, 3, 4];
         let bytes = Bytes::from(content.clone());
 
-        // Test TryFrom<Bytes>
         let piece_content = PieceContent::try_from(bytes.clone()).unwrap();
-
-        // Test From<PieceContent> for Bytes
         let bytes_back: Bytes = piece_content.clone().into();
         assert_eq!(bytes_back, content);
     }
 
     #[test]
     fn test_invalid_conversion() {
-        // Create bytes larger than MAX_PIECE_SIZE
-        let large_content = vec![0; MAX_PIECE_SIZE + 1];
+        let large_content = vec![0; MAX_VALUE_SIZE + 1];
         let bytes = Bytes::from(large_content);
 
-        // Test conversion fails
         let result = PieceContent::try_from(bytes);
         assert!(result.is_err());
         match result {