style: apply cargo fmt formatting

Apply rustfmt to fix CI formatting checks.

Author: chiradip

core/common/src/types/message/mod.rs

@@ -39,9 +39,7 @@ pub use crate::commands::messages::poll_messages::PollMessages;
 pub use crate::commands::messages::send_messages::SendMessages;
 pub use iggy_message::{IggyMessage, MAX_PAYLOAD_SIZE, MAX_USER_HEADERS_SIZE};
 pub use index::IggyIndex;
-pub use index_cache_line_block::{
-    IndexCacheLineBlock, CACHE_LINE_SIZE, ENTRIES_PER_CACHE_LINE,
-};
+pub use index_cache_line_block::{CACHE_LINE_SIZE, ENTRIES_PER_CACHE_LINE, IndexCacheLineBlock};
 pub use index_view::IggyIndexView;
 pub use indexes::IggyIndexes;
 pub use message_header::{

core/server/src/streaming/segments/indexes/indexes_mut.rs

@@ -18,7 +18,7 @@
 
 use crate::streaming::utils::aligned_buffer;
 use iggy_common::PooledBuffer;
-use iggy_common::{INDEX_SIZE, IggyIndexView, IndexCacheLineBlock, ENTRIES_PER_CACHE_LINE};
+use iggy_common::{ENTRIES_PER_CACHE_LINE, INDEX_SIZE, IggyIndexView, IndexCacheLineBlock};
 use std::fmt;
 use std::ops::{Deref, Index as StdIndex};
 
@@ -411,7 +411,8 @@ impl IggyIndexesMut {
             let remaining_entries = self.count() % ENTRIES_PER_CACHE_LINE as u32;
             if remaining_entries > 0 {
                 // Fall back to entry-level search for incomplete block
-                return self.binary_search_position_for_timestamp_sync(target_timestamp)
+                return self
+                    .binary_search_position_for_timestamp_sync(target_timestamp)
                     .map(|pos| {
                         let block_idx = pos / ENTRIES_PER_CACHE_LINE as u32;
                         let entry_idx = (pos % ENTRIES_PER_CACHE_LINE as u32) as usize;
@@ -466,8 +467,13 @@ impl IggyIndexesMut {
     ///
     /// # Returns
     /// The first index with timestamp >= target_timestamp, or None if not found
-    pub fn find_by_timestamp_block_aware(&self, target_timestamp: u64) -> Option<IggyIndexView<'_>> {
-        if let Some((block_idx, entry_idx)) = self.binary_search_blocks_by_timestamp(target_timestamp) {
+    pub fn find_by_timestamp_block_aware(
+        &self,
+        target_timestamp: u64,
+    ) -> Option<IggyIndexView<'_>> {
+        if let Some((block_idx, entry_idx)) =
+            self.binary_search_blocks_by_timestamp(target_timestamp)
+        {
             let global_index = block_idx * ENTRIES_PER_CACHE_LINE as u32 + entry_idx as u32;
             self.get(global_index)
         } else {

core/server/src/streaming/segments/indexes/indexes_mut_bench.rs

@@ -20,7 +20,7 @@
 mod benchmarks {
     use crate::configs::system::SystemConfig;
     use crate::streaming::segments::indexes::indexes_mut::IggyIndexesMut;
-    use iggy_common::{MemoryPool, MEMORY_POOL};
+    use iggy_common::{MEMORY_POOL, MemoryPool};
     use std::sync::{Arc, Once};
     use std::time::Instant;
 
@@ -40,11 +40,7 @@ mod benchmarks {
         let mut indexes = IggyIndexesMut::with_capacity(size, 0);
 
         for i in 0..size as u32 {
-            indexes.insert(
-                i,
-                i * 1000,
-                1000000 + (i as u64 * 1000),
-            );
+            indexes.insert(i, i * 1000, 1000000 + (i as u64 * 1000));
         }
 
         indexes
@@ -149,7 +145,8 @@ mod benchmarks {
     fn bench_memory_footprint() {
         for size in [1_000, 10_000, 100_000, 1_000_000].iter() {
             let indexes = create_indexes(*size);
-            let memory_bytes = indexes.count() as usize * std::mem::size_of::<iggy_common::IggyIndex>();
+            let memory_bytes =
+                indexes.count() as usize * std::mem::size_of::<iggy_common::IggyIndex>();
             let memory_mb = memory_bytes as f64 / 1024.0 / 1024.0;
 
             println!(
@@ -206,7 +203,10 @@ mod benchmarks {
         let indexes = create_indexes(size);
 
         println!("\nCache efficiency metrics for {} entries:", size);
-        println!("  Index entry size: {} bytes", std::mem::size_of::<iggy_common::IggyIndex>());
+        println!(
+            "  Index entry size: {} bytes",
+            std::mem::size_of::<iggy_common::IggyIndex>()
+        );
         println!("  Entries per cache line: 4");
         println!("  Total blocks: {}", indexes.block_count());
         println!("  Buffer aligned: {}", indexes.is_buffer_aligned());
@@ -222,7 +222,8 @@ mod benchmarks {
         let regular_cache_lines = regular_probes * 2.0;
         let block_cache_lines = block_probes; // Each block = 1 cache line
 
-        let cache_reduction = ((regular_cache_lines - block_cache_lines) / regular_cache_lines) * 100.0;
+        let cache_reduction =
+            ((regular_cache_lines - block_cache_lines) / regular_cache_lines) * 100.0;
 
         println!("\nExpected cache behavior:");
         println!("  Regular search probes: {:.0}", regular_probes);

core/server/src/streaming/segments/indexes/indexes_mut_block_tests.rs

@@ -18,10 +18,10 @@
 
 #[cfg(test)]
 mod tests {
-    use crate::streaming::segments::indexes::indexes_mut::IggyIndexesMut;
-    use iggy_common::{MemoryPool, MEMORY_POOL};
     use crate::configs::system::SystemConfig;
+    use crate::streaming::segments::indexes::indexes_mut::IggyIndexesMut;
     use iggy_common::ENTRIES_PER_CACHE_LINE;
+    use iggy_common::{MEMORY_POOL, MemoryPool};
     use std::sync::{Arc, Once};
 
     static INIT: Once = Once::new();
@@ -45,8 +45,8 @@ mod tests {
 
         for i in 0..count {
             indexes.insert(
-                i,                          // offset
-                i * 1000,                   // position
+                i,                           // offset
+                i * 1000,                    // position
                 1000000 + (i as u64 * 1000), // timestamp
             );
         }
@@ -86,7 +86,7 @@ mod tests {
 
         // Get middle block
         let block2 = indexes.get_block(2).expect("Block 2 should exist");
-        assert_eq!(block2.get(0).unwrap().offset, 8);  // 2 * 4 = 8
+        assert_eq!(block2.get(0).unwrap().offset, 8); // 2 * 4 = 8
         assert_eq!(block2.get(1).unwrap().offset, 9);
         assert_eq!(block2.get(2).unwrap().offset, 10);
         assert_eq!(block2.get(3).unwrap().offset, 11);
@@ -167,16 +167,22 @@ mod tests {
         let indexes = create_test_indexes(20);
 
         // Exact match
-        let idx = indexes.find_by_timestamp_block_aware(1005000).expect("Should find");
+        let idx = indexes
+            .find_by_timestamp_block_aware(1005000)
+            .expect("Should find");
         assert_eq!(idx.offset(), 5);
         assert_eq!(idx.timestamp(), 1005000);
 
         // Between timestamps
-        let idx = indexes.find_by_timestamp_block_aware(1005500).expect("Should find");
+        let idx = indexes
+            .find_by_timestamp_block_aware(1005500)
+            .expect("Should find");
         assert_eq!(idx.offset(), 6); // Next higher
 
         // Before first
-        let idx = indexes.find_by_timestamp_block_aware(999000).expect("Should find");
+        let idx = indexes
+            .find_by_timestamp_block_aware(999000)
+            .expect("Should find");
         assert_eq!(idx.offset(), 0);
 
         // After last
@@ -189,12 +195,12 @@ mod tests {
         let indexes = create_test_indexes(100);
 
         let test_timestamps = vec![
-            1000000,  // First
-            1050000,  // Middle
-            1099000,  // Last
-            999000,   // Before first
-            1025500,  // Between entries
-            2000000,  // After last
+            1000000, // First
+            1050000, // Middle
+            1099000, // Last
+            999000,  // Before first
+            1025500, // Between entries
+            2000000, // After last
         ];
 
         for timestamp in test_timestamps {
@@ -206,12 +212,14 @@ mod tests {
                     assert_eq!(
                         block_idx.offset(),
                         regular_idx.offset(),
-                        "Mismatch for timestamp {}", timestamp
+                        "Mismatch for timestamp {}",
+                        timestamp
                     );
                     assert_eq!(
                         block_idx.timestamp(),
                         regular_idx.timestamp(),
-                        "Mismatch for timestamp {}", timestamp
+                        "Mismatch for timestamp {}",
+                        timestamp
                     );
                 }
                 (None, None) => {
@@ -257,15 +265,21 @@ mod tests {
         assert_eq!(indexes.block_count(), 250);
 
         // Search near beginning
-        let idx = indexes.find_by_timestamp_block_aware(1001000).expect("Should find");
+        let idx = indexes
+            .find_by_timestamp_block_aware(1001000)
+            .expect("Should find");
         assert_eq!(idx.offset(), 1);
 
         // Search in middle
-        let idx = indexes.find_by_timestamp_block_aware(1500000).expect("Should find");
+        let idx = indexes
+            .find_by_timestamp_block_aware(1500000)
+            .expect("Should find");
         assert_eq!(idx.offset(), 500);
 
         // Search near end
-        let idx = indexes.find_by_timestamp_block_aware(1999000).expect("Should find");
+        let idx = indexes
+            .find_by_timestamp_block_aware(1999000)
+            .expect("Should find");
         assert_eq!(idx.offset(), 999);
     }
 }