Fix warnings + fmt

Author: johnramsden

oxcache/src/bin/spclient.rs

@@ -6,13 +6,13 @@ use oxcache::request;
 use oxcache::request::{GetRequest, Request};
 use std::fs::File;
 use std::io::{BufRead, BufReader, ErrorKind};
-use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicUsize, Ordering};
 use std::time::Instant;
 use tokio::net::UnixStream;
 use tokio::sync::Mutex;
 use tokio::task::JoinHandle;
-use tokio::time::{timeout, Duration};
+use tokio::time::{Duration, timeout};
 use tokio_util::codec::{FramedRead, FramedWrite, LengthDelimitedCodec};
 
 const MAX_FRAME_LENGTH: usize = 2 * 1024 * 1024 * 1024; // 2 GB
@@ -303,11 +303,9 @@ async fn run_real_mode(
         for qreq in quantized {
             // Validate request size
             if qreq.size > MAX_FRAME_LENGTH as u64 {
-                return Err(format!(
-                    "Request size {} exceeds MAX_FRAME_LENGTH (2GB)",
-                    qreq.size
-                )
-                .into());
+                return Err(
+                    format!("Request size {} exceeds MAX_FRAME_LENGTH (2GB)", qreq.size).into(),
+                );
             }
 
             get_requests.push(GetRequest {
@@ -379,11 +377,18 @@ async fn run_real_mode(
                 }
 
                 // Send request with timeout
-                let encoded =
-                    bincode::serde::encode_to_vec(Request::Get(request), bincode::config::standard())
-                        .unwrap();
+                let encoded = bincode::serde::encode_to_vec(
+                    Request::Get(request),
+                    bincode::config::standard(),
+                )
+                .unwrap();
 
-                match timeout(Duration::from_secs(REQUEST_TIMEOUT_SECS), writer.send(Bytes::from(encoded))).await {
+                match timeout(
+                    Duration::from_secs(REQUEST_TIMEOUT_SECS),
+                    writer.send(Bytes::from(encoded)),
+                )
+                .await
+                {
                     Ok(Ok(_)) => {
                         // Send successful
                     }
@@ -396,7 +401,10 @@ async fn run_real_mode(
                     Err(_) => {
                         return Err(std::io::Error::new(
                             ErrorKind::TimedOut,
-                            format!("[Client {}] Send timeout after {} seconds", client_id, REQUEST_TIMEOUT_SECS),
+                            format!(
+                                "[Client {}] Send timeout after {} seconds",
+                                client_id, REQUEST_TIMEOUT_SECS
+                            ),
                         ));
                     }
                 }
@@ -430,16 +438,23 @@ async fn run_real_mode(
                         // Server closed connection gracefully - this is expected behavior
                         // when server reaches benchmark target and shuts down
                         let completed_reqs = counter.load(Ordering::Relaxed);
-                        println!("[Client {}] Server closed connection gracefully after {} requests",
-                                 client_id, completed_reqs);
-                        println!("[Client {}] This is expected when server reaches benchmark target",
-                                 client_id);
+                        println!(
+                            "[Client {}] Server closed connection gracefully after {} requests",
+                            client_id, completed_reqs
+                        );
+                        println!(
+                            "[Client {}] This is expected when server reaches benchmark target",
+                            client_id
+                        );
                         return Ok(());
                     }
                     Err(_) => {
                         return Err(std::io::Error::new(
                             ErrorKind::TimedOut,
-                            format!("[Client {}] Receive timeout after {} seconds", client_id, REQUEST_TIMEOUT_SECS),
+                            format!(
+                                "[Client {}] Receive timeout after {} seconds",
+                                client_id, REQUEST_TIMEOUT_SECS
+                            ),
                         ));
                     }
                 }
@@ -470,10 +485,15 @@ async fn run_real_mode(
 
     println!("\n=== Execution Complete ===");
     if completed_requests < nr_requests {
-        println!("NOTE: Server shutdown before all requests completed (expected for byte-target benchmarks)");
-        println!("Completed {} of {} requests ({:.1}%)",
-                 completed_requests, nr_requests,
-                 (completed_requests as f64 / nr_requests as f64) * 100.0);
+        println!(
+            "NOTE: Server shutdown before all requests completed (expected for byte-target benchmarks)"
+        );
+        println!(
+            "Completed {} of {} requests ({:.1}%)",
+            completed_requests,
+            nr_requests,
+            (completed_requests as f64 / nr_requests as f64) * 100.0
+        );
     } else {
         println!("Completed all {} requests", nr_requests);
     }

oxcache/src/bin/test_subset_reads.rs

@@ -1,5 +1,5 @@
-use bytes::Bytes;
 use bincode::error::DecodeError;
+use bytes::Bytes;
 use futures::{SinkExt, StreamExt};
 use oxcache::request::{GetRequest, GetResponse, Request};
 use std::time::Duration;
@@ -29,7 +29,12 @@ impl TestClient {
         Ok(Self { reader, writer })
     }
 
-    async fn get(&mut self, key: String, offset: u64, size: u64) -> Result<Bytes, Box<dyn std::error::Error>> {
+    async fn get(
+        &mut self,
+        key: String,
+        offset: u64,
+        size: u64,
+    ) -> Result<Bytes, Box<dyn std::error::Error>> {
         let request = Request::Get(GetRequest { key, offset, size });
 
         let encoded = bincode::serde::encode_to_vec(request, bincode::config::standard())?;
@@ -70,11 +75,11 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let chunk_size = 65536; // 64KB chunk size
     let lba_size = 4096; // 4KB logical block size
     let test_cases = vec![
-        (0, lba_size),           // Read first 4KB (includes header)
-        (lba_size, lba_size),    // Read second 4KB block
-        (lba_size * 2, lba_size), // Read third 4KB block
+        (0, lba_size),                // Read first 4KB (includes header)
+        (lba_size, lba_size),         // Read second 4KB block
+        (lba_size * 2, lba_size),     // Read third 4KB block
         (lba_size * 4, lba_size * 2), // Read 8KB starting at 16KB offset
-        (0, chunk_size),         // Read entire chunk
+        (0, chunk_size),              // Read entire chunk
     ];
 
     for (offset, size) in test_cases {
@@ -108,7 +113,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     // Test LBA-aligned edge cases
     let edge_cases = vec![
-        (0, lba_size),                    // Single LBA at start
+        (0, lba_size),                     // Single LBA at start
         (chunk_size - lba_size, lba_size), // Single LBA at end
     ];
 
@@ -144,7 +149,11 @@ fn validate_subset_data(data: &Bytes, key: &str, offset: u64, size: u64) -> bool
     println!("Expected data length: {}", size);
 
     if data.len() != size as usize {
-        println!("ERROR: Data length mismatch: expected {}, got {}", size, data.len());
+        println!(
+            "ERROR: Data length mismatch: expected {}, got {}",
+            size,
+            data.len()
+        );
         return false;
     }
 
@@ -154,19 +163,34 @@ fn validate_subset_data(data: &Bytes, key: &str, offset: u64, size: u64) -> bool
 
     // Show more bytes for comparison
     let show_bytes = std::cmp::min(32, std::cmp::min(data.len(), expected_data.len()));
-    println!("Expected first {} bytes: {:02x?}", show_bytes, &expected_data[0..show_bytes]);
-    println!("Actual first {} bytes:   {:02x?}", show_bytes, &data[0..show_bytes]);
+    println!(
+        "Expected first {} bytes: {:02x?}",
+        show_bytes,
+        &expected_data[0..show_bytes]
+    );
+    println!(
+        "Actual first {} bytes:   {:02x?}",
+        show_bytes,
+        &data[0..show_bytes]
+    );
 
     // Find first mismatch
     for (i, (actual, expected)) in data.iter().zip(expected_data.iter()).enumerate() {
         if actual != expected {
-            println!("ERROR: First mismatch at byte {}: expected 0x{:02x}, got 0x{:02x}", i, expected, actual);
+            println!(
+                "ERROR: First mismatch at byte {}: expected 0x{:02x}, got 0x{:02x}",
+                i, expected, actual
+            );
             return false;
         }
     }
 
     if data.len() != expected_data.len() {
-        println!("ERROR: Length mismatch after byte comparison: actual {}, expected {}", data.len(), expected_data.len());
+        println!(
+            "ERROR: Length mismatch after byte comparison: actual {}, expected {}",
+            data.len(),
+            expected_data.len()
+        );
         return false;
     }
 
@@ -179,7 +203,10 @@ fn generate_expected_subset_data(key: &str, offset: u64, size: u64) -> Vec<u8> {
     use std::collections::hash_map::DefaultHasher;
     use std::hash::{Hash, Hasher};
 
-    println!("=== DEBUG: Generating expected data for offset={}, size={} ===", offset, size);
+    println!(
+        "=== DEBUG: Generating expected data for offset={}, size={} ===",
+        offset, size
+    );
 
     const EMULATED_BUFFER_SEED: u64 = 1;
     const CHUNK_SIZE: u64 = 65536; // Match our test chunk size
@@ -194,8 +221,8 @@ fn generate_expected_subset_data(key: &str, offset: u64, size: u64) -> Vec<u8> {
     println!("Key hash: 0x{:016x}", key_hash);
 
     let mut full_chunk = Vec::new();
-    full_chunk.extend_from_slice(&key_hash.to_be_bytes());  // 8 bytes
-    full_chunk.extend_from_slice(&0u64.to_be_bytes());      // 8 bytes - offset=0
+    full_chunk.extend_from_slice(&key_hash.to_be_bytes()); // 8 bytes
+    full_chunk.extend_from_slice(&0u64.to_be_bytes()); // 8 bytes - offset=0
     full_chunk.extend_from_slice(&CHUNK_SIZE.to_be_bytes()); // 8 bytes - size=chunk_size
 
     println!("Header (24 bytes): {:02x?}", &full_chunk[0..24]);
@@ -217,7 +244,10 @@ fn generate_expected_subset_data(key: &str, offset: u64, size: u64) -> Vec<u8> {
 
     let result = full_chunk[start..end].to_vec();
     println!("Extracted subset length: {}", result.len());
-    println!("Extracted first 32 bytes: {:02x?}", &result[0..std::cmp::min(32, result.len())]);
+    println!(
+        "Extracted first 32 bytes: {:02x?}",
+        &result[0..std::cmp::min(32, result.len())]
+    );
 
     result
-}
+}

oxcache/src/cache/bucket.rs

@@ -1,9 +1,12 @@
 use crate::request::GetRequest;
+use bytes::Bytes;
+use lru_mem::HeapSize;
 use nvme::types::{Byte, Zone};
-use std::sync::{Arc, atomic::{AtomicUsize, Ordering}};
+use std::sync::{
+    Arc,
+    atomic::{AtomicUsize, Ordering},
+};
 use tokio::sync::{Notify, RwLock};
-use lru_mem::HeapSize;
-use bytes::Bytes;
 
 #[derive(Debug, Clone)]
 pub struct Chunk {
@@ -72,7 +75,11 @@ impl PinnedChunkLocation {
     /// Pin this location (increment ref count). Returns a guard that will unpin on drop.
     pub fn pin(self: &Arc<Self>) -> PinGuard {
         let new_count = self.pin_count.fetch_add(1, Ordering::SeqCst) + 1;
-        tracing::debug!("Pinning location {:?}, pin_count now: {}", self.location, new_count);
+        tracing::debug!(
+            "Pinning location {:?}, pin_count now: {}",
+            self.location,
+            new_count
+        );
         PinGuard::new(self)
     }
 
@@ -99,8 +106,12 @@ impl PinnedChunkLocation {
     fn unpin(&self) {
         let old_count = self.pin_count.fetch_sub(1, Ordering::SeqCst);
         let new_count = old_count - 1;
-        tracing::debug!("Unpinning location {:?}, pin_count now: {}", self.location, new_count);
-        
+        tracing::debug!(
+            "Unpinning location {:?}, pin_count now: {}",
+            self.location,
+            new_count
+        );
+
         // If pin count reached 0, notify any waiting eviction threads
         if new_count == 0 {
             self.unpin_notify.notify_waiters();
@@ -117,7 +128,7 @@ pub struct PinGuard {
 
 impl PinGuard {
     fn new(pinned_location: &Arc<PinnedChunkLocation>) -> Self {
-        Self { 
+        Self {
             location: pinned_location.location.clone(),
             pinned_location: Arc::clone(pinned_location),
         }