format moment

Author: taisirhassan

benches/codec_bench.rs

@@ -1,5 +1,5 @@
-use criterion::{criterion_group, criterion_main, Criterion, black_box};
 use cipherstream::file_transfer::{FileTransferCodec, FileTransferProtocol, ProtocolRequest};
+use criterion::{Criterion, black_box, criterion_group, criterion_main};
 use futures::io::Cursor;
 use libp2p::request_response::Codec;
 
@@ -20,7 +20,10 @@ fn bench_codec_request_roundtrip(c: &mut Criterion) {
             // write phase
             futures::executor::block_on(async {
                 let mut w = Cursor::new(&mut buf);
-                let _ = codec.write_request(&protocol, &mut w, request.clone()).await.unwrap();
+                codec
+                    .write_request(&protocol, &mut w, request.clone())
+                    .await
+                    .unwrap();
             });
             // read phase
             futures::executor::block_on(async {
@@ -34,4 +37,3 @@ fn bench_codec_request_roundtrip(c: &mut Criterion) {
 
 criterion_group!(benches, bench_codec_request_roundtrip);
 criterion_main!(benches);
-

benches/hash_bench.rs

@@ -1,7 +1,7 @@
-use criterion::{criterion_group, criterion_main, Criterion, black_box};
 use cipherstream::crypto;
-use tempfile::NamedTempFile;
+use criterion::{Criterion, black_box, criterion_group, criterion_main};
 use std::io::Write;
+use tempfile::NamedTempFile;
 
 fn bench_file_hashing(c: &mut Criterion) {
     let sizes = [1024usize, 1024 * 64, 1024 * 1024];
@@ -11,7 +11,9 @@ fn bench_file_hashing(c: &mut Criterion) {
         let path = tmp.path().to_path_buf();
         c.bench_function(&format!("hash_file_{}KB", size / 1024), |b| {
             b.iter(|| {
-                let _ = futures::executor::block_on(async { crypto::compute_file_hash(&path).await.unwrap() });
+                let _ = futures::executor::block_on(async {
+                    crypto::compute_file_hash(&path).await.unwrap()
+                });
                 black_box(());
             })
         });
@@ -20,4 +22,3 @@ fn bench_file_hashing(c: &mut Criterion) {
 
 criterion_group!(benches, bench_file_hashing);
 criterion_main!(benches);
-

benches/request_response_bench.rs

@@ -1,5 +1,5 @@
-use criterion::{criterion_group, criterion_main, Criterion, black_box};
-use cipherstream::file_transfer::{FileTransferCodec, FileTransferProtocol, ProtocolRequest, ProtocolResponse};
+use cipherstream::file_transfer::{FileTransferCodec, FileTransferProtocol, ProtocolResponse};
+use criterion::{Criterion, black_box, criterion_group, criterion_main};
 use futures::io::Cursor;
 use libp2p::request_response::Codec;
 
@@ -19,7 +19,10 @@ fn bench_codec_response_roundtrip(c: &mut Criterion) {
             // write phase
             futures::executor::block_on(async {
                 let mut w = Cursor::new(&mut buf);
-                let _ = codec.write_response(&protocol, &mut w, response.clone()).await.unwrap();
+                codec
+                    .write_response(&protocol, &mut w, response.clone())
+                    .await
+                    .unwrap();
             });
             // read phase
             futures::executor::block_on(async {
@@ -33,4 +36,3 @@ fn bench_codec_response_roundtrip(c: &mut Criterion) {
 
 criterion_group!(benches, bench_codec_response_roundtrip);
 criterion_main!(benches);
-

src/application/dto.rs

@@ -50,4 +50,4 @@ pub struct SendFileResponse {
 pub struct ErrorResponse {
     pub error: String,
     pub details: Option<String>,
-} 
+}

src/application/mod.rs

@@ -1,7 +1,7 @@
-pub mod use_cases;
-pub mod services;
 pub mod dto;
+pub mod services;
+pub mod use_cases;
 
-pub use use_cases::*;
+pub use dto::*;
 pub use services::*;
-pub use dto::*; 
+pub use use_cases::*;

src/application/services.rs

@@ -1,17 +1,17 @@
-use std::sync::Arc;
 use crate::core::traits::*;
-use crate::infrastructure::{repositories::*, config::AppConfig, UtilityService};
+use crate::infrastructure::{UtilityService, config::AppConfig, repositories::*};
+use std::sync::Arc;
 
 /// Application service that provides dependency injection and orchestrates the system
 pub struct ApplicationService {
     pub config: Arc<AppConfig>,
     // pub use_cases: Arc<super::UseCases>,
-    
+
     // Domain services
     // pub transfer_service: Arc<TransferDomainService>,
     // pub peer_service: Arc<PeerDomainService>,
     // pub file_service: Arc<FileDomainService>,
-    
+
     // Repositories
     pub file_repository: Arc<dyn FileRepository>,
     pub transfer_repository: Arc<dyn TransferRepository>,
@@ -24,7 +24,7 @@ impl ApplicationService {
         // Validate and prepare configuration
         config.validate()?;
         config.ensure_directories()?;
-        
+
         let config = Arc::new(config);
 
         // Create repositories
@@ -53,9 +53,7 @@ pub struct FileSystemService {
 
 impl FileSystemService {
     pub fn new(config: Arc<AppConfig>) -> Self {
-        Self { 
-            _config: config,
-        }
+        Self { _config: config }
     }
 }
 
@@ -64,7 +62,7 @@ impl FileService for FileSystemService {
     async fn add_file(&self, path: &str) -> DomainResult<crate::core::domain::File> {
         let (name, size) = self.get_file_metadata(path).await?;
         let hash = self.calculate_file_hash(path).await?;
-        
+
         Ok(crate::core::domain::File {
             id: crate::core::domain::FileId::new(),
             name,
@@ -85,43 +83,43 @@ impl FileService for FileSystemService {
     async fn get_file_metadata(&self, path: &str) -> DomainResult<(String, u64)> {
         let path_buf = std::path::Path::new(path);
         let metadata = tokio::fs::metadata(path).await?;
-        
+
         let name = path_buf
             .file_name()
             .ok_or("Invalid filename")?
             .to_string_lossy()
             .to_string();
-        
+
         Ok((name, metadata.len()))
     }
 
     async fn read_file_chunk(&self, path: &str, offset: u64, size: usize) -> DomainResult<Vec<u8>> {
         use tokio::io::{AsyncReadExt, AsyncSeekExt};
-        
+
         let mut file = tokio::fs::File::open(path).await?;
         file.seek(std::io::SeekFrom::Start(offset)).await?;
-        
+
         let mut buffer = vec![0u8; size];
         let bytes_read = file.read(&mut buffer).await?;
         buffer.truncate(bytes_read);
-        
+
         Ok(buffer)
     }
 
     async fn write_file_chunk(&self, path: &str, offset: u64, data: &[u8]) -> DomainResult<()> {
-        use tokio::io::{AsyncWriteExt, AsyncSeekExt};
-        
+        use tokio::io::{AsyncSeekExt, AsyncWriteExt};
+
         let mut file = tokio::fs::OpenOptions::new()
             .create(true)
             .write(true)
             .truncate(false)
             .open(path)
             .await?;
-        
+
         file.seek(std::io::SeekFrom::Start(offset)).await?;
         file.write_all(data).await?;
         file.flush().await?;
-        
+
         Ok(())
     }
-} 
+}

src/application/use_cases.rs

@@ -1,5 +1,5 @@
+use crate::core::{domain::*, services::*, traits::*};
 use std::sync::Arc;
-use crate::core::{domain::*, traits::*, services::*};
 
 /// Use case for sending a file to another peer
 pub struct SendFileUseCase {
@@ -153,4 +153,4 @@ impl UseCases {
             cancel_transfer: CancelTransferUseCase::new(transfer_service),
         }
     }
-} 
+}