refactor(consensus): satisfy rust lints

Author: windsornguyen

cloud9-node/src/lib.rs

@@ -5,18 +5,12 @@ use cloud9_storage::StorageOptions;
 use tracing::{info, instrument};
 
 /// Runtime configuration derived from CLI flags and config files.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default)]
 pub struct NodeConfig {
     pub storage: StorageOptions,
     pub consensus: ConsensusConfig,
 }
 
-impl Default for NodeConfig {
-    fn default() -> Self {
-        Self { storage: StorageOptions::default(), consensus: ConsensusConfig::default() }
-    }
-}
-
 /// Launch the storage and consensus subsystems.
 #[instrument(skip_all)]
 pub async fn launch(config: NodeConfig) {

cloud9/src/main.rs

@@ -47,7 +47,7 @@ fn main() -> Result<()> {
     match cli.command {
         Command::Start { config } => {
             let config_path = config.unwrap_or_else(|| PathBuf::from("cloud9.toml"));
-            let maybe_config = load_config(config_path.clone())?;
+            let maybe_config = load_config(&config_path)?;
             tracing::info!(path = %config_path.display(), "booting node");
             if let Some(config) = maybe_config {
                 tracing::debug!(contents = %config, "loaded configuration");
@@ -56,7 +56,7 @@ fn main() -> Result<()> {
             }
         }
         Command::CheckConfig { config } => {
-            load_config(config.clone())
+            load_config(&config)
                 .and_then(|contents| {
                     contents.ok_or_else(|| miette::miette!("config `{}` missing", config.display()))
                 })
@@ -89,9 +89,9 @@ fn init_tracing(verbosity: u8, color_enabled: bool) -> Result<()> {
     tracing_subscriber::registry().with(filter).with(fmt_layer).try_init().into_diagnostic()
 }
 
-fn load_config(path: PathBuf) -> Result<Option<String>> {
+fn load_config(path: &PathBuf) -> Result<Option<String>> {
     if path.exists() {
-        fs::read_to_string(&path)
+        fs::read_to_string(path)
             .into_diagnostic()
             .map(Some)
             .with_context(|| format!("reading configuration from `{}`", path.display()))

consensus/cloud9-raft-io/src/lib.rs

@@ -1,4 +1,5 @@
 //! I/O layer for cloud9-raft.
+#![cfg_attr(test, allow(clippy::unwrap_used))]
 //!
 //! This crate provides the integration between the pure Raft state machine
 //! (`cloud9-raft`) and the outside world. It defines traits for:
@@ -24,6 +25,8 @@ mod storage;
 mod transport;
 
 pub use read_index::{ReadId, ReadIndexCoordinator, ReadIndexError, ReadIndexResult};
-pub use session::{ClientId, ClientSession, DuplicateCheck, SequenceNum, SessionRequest, SessionTracker};
+pub use session::{
+    ClientId, ClientSession, DuplicateCheck, SequenceNum, SessionRequest, SessionTracker,
+};
 pub use storage::{SnapshotData, Storage, StorageError};
 pub use transport::{Transport, TransportError};

consensus/cloud9-raft-io/src/read_index.rs

@@ -9,7 +9,7 @@
 //! 2. Leader records the current commit index as the "read index"
 //! 3. Leader sends a heartbeat round and waits for majority acknowledgment
 //! 4. Once majority confirms, the leader is guaranteed to still be leader
-//! 5. The read can proceed once the state machine has applied up to read_index
+//! 5. The read can proceed once the state machine has applied up to `read_index`
 //!
 //! This module provides `ReadIndexCoordinator` which tracks pending reads and
 //! completes them when heartbeat quorum is achieved.
@@ -33,7 +33,7 @@ impl ReadId {
 /// A pending read request awaiting heartbeat confirmation.
 #[derive(Debug)]
 struct PendingRead {
-    /// The read index (commit_index when request was made).
+    /// The read index (`commit_index` when request was made).
     read_index: LogIndex,
     /// Heartbeat round this read is waiting on.
     round: u64,
@@ -134,13 +134,7 @@ impl ReadIndexCoordinator {
     /// The caller is responsible for checking `can_serve_reads()` before calling this.
     pub fn request_read(&mut self, read_index: LogIndex) -> ReadId {
         let id = self.next_read_id.next();
-        self.pending.insert(
-            id,
-            PendingRead {
-                read_index,
-                round: self.current_round,
-            },
-        );
+        self.pending.insert(id, PendingRead { read_index, round: self.current_round });
         id
     }
 
@@ -166,7 +160,7 @@ impl ReadIndexCoordinator {
     /// Record a heartbeat acknowledgment from a peer.
     ///
     /// Call this when an `AppendResponse { success: true }` is received
-    /// from a heartbeat (empty AppendEntries).
+    /// from a heartbeat (empty `AppendEntries`).
     pub fn record_ack(&mut self, from: NodeId) {
         if !self.round_acks.contains(&from) && self.voters.contains(&from) {
             self.round_acks.push(from);

consensus/cloud9-raft-io/src/session.rs

@@ -7,7 +7,7 @@
 //!
 //! The solution is to track client sessions:
 //! 1. Clients register and receive unique IDs
-//! 2. Each request carries (client_id, sequence_number)
+//! 2. Each request carries (`client_id`, `sequence_number`)
 //! 3. The state machine tracks the last completed sequence per client
 //! 4. Duplicate requests return cached responses
 //!
@@ -95,10 +95,7 @@ pub struct ClientSession<R> {
 
 impl<R> Default for ClientSession<R> {
     fn default() -> Self {
-        Self {
-            last_sequence: 0,
-            last_response: None,
-        }
+        Self { last_sequence: 0, last_response: None }
     }
 }
 
@@ -138,10 +135,7 @@ pub struct SessionTracker<R> {
 impl<R: Clone> SessionTracker<R> {
     /// Create a new session tracker.
     pub fn new() -> Self {
-        Self {
-            sessions: BTreeMap::new(),
-            next_client_id: 1,
-        }
+        Self { sessions: BTreeMap::new(), next_client_id: 1 }
     }
 
     /// Register a new client session.
@@ -185,12 +179,7 @@ impl<R: Clone> SessionTracker<R> {
     ///
     /// Call this after executing a command. Caches the response for
     /// duplicate detection.
-    pub fn record_completion(
-        &mut self,
-        client_id: ClientId,
-        sequence: SequenceNum,
-        response: R,
-    ) {
+    pub fn record_completion(&mut self, client_id: ClientId, sequence: SequenceNum, response: R) {
         let session = self.sessions.entry(client_id).or_default();
         if sequence > session.last_sequence {
             session.last_sequence = sequence;
@@ -244,10 +233,7 @@ mod tests {
         let mut tracker: SessionTracker<String> = SessionTracker::new();
         let client = tracker.register_client();
 
-        assert!(matches!(
-            tracker.check_duplicate(client, 1),
-            DuplicateCheck::New
-        ));
+        assert!(matches!(tracker.check_duplicate(client, 1), DuplicateCheck::New));
     }
 
     #[test]
@@ -274,10 +260,7 @@ mod tests {
         tracker.record_completion(client, 5, "response5".to_string());
 
         // Sequence 3 is stale
-        assert!(matches!(
-            tracker.check_duplicate(client, 3),
-            DuplicateCheck::Stale
-        ));
+        assert!(matches!(tracker.check_duplicate(client, 3), DuplicateCheck::Stale));
     }
 
     #[test]
@@ -288,10 +271,7 @@ mod tests {
         tracker.record_completion(client, 1, "response1".to_string());
 
         // Sequence 2 is new
-        assert!(matches!(
-            tracker.check_duplicate(client, 2),
-            DuplicateCheck::New
-        ));
+        assert!(matches!(tracker.check_duplicate(client, 2), DuplicateCheck::New));
     }
 
     #[test]
@@ -309,10 +289,7 @@ mod tests {
         let tracker: SessionTracker<String> = SessionTracker::new();
         let unknown = ClientId(999);
 
-        assert!(matches!(
-            tracker.check_duplicate(unknown, 1),
-            DuplicateCheck::New
-        ));
+        assert!(matches!(tracker.check_duplicate(unknown, 1), DuplicateCheck::New));
     }
 
     #[test]

consensus/cloud9-raft-io/src/storage.rs

@@ -43,19 +43,28 @@ pub trait Storage: Send + Sync {
     ///
     /// Per §3.8, this must complete before responding to any RPC.
     /// If `sync` is true, the implementation should fsync to ensure durability.
-    fn save(&self, state: &Persistent, sync: bool) -> impl Future<Output = Result<(), StorageError>> + Send;
+    fn save(
+        &self,
+        state: &Persistent,
+        sync: bool,
+    ) -> impl Future<Output = Result<(), StorageError>> + Send;
 
     /// Load snapshot data for transfer to a slow follower (§5).
     ///
     /// Returns the snapshot data as bytes. The format is opaque to Raft —
     /// the state machine defines it.
-    fn load_snapshot(&self) -> impl Future<Output = Result<Option<SnapshotData>, StorageError>> + Send;
+    fn load_snapshot(
+        &self,
+    ) -> impl Future<Output = Result<Option<SnapshotData>, StorageError>> + Send;
 
     /// Save snapshot data received from the leader (§5).
     ///
-    /// Called when a follower receives InstallSnapshot. The implementation
+    /// Called when a follower receives `InstallSnapshot`. The implementation
     /// should atomically replace any existing snapshot.
-    fn save_snapshot(&self, snapshot: SnapshotData) -> impl Future<Output = Result<(), StorageError>> + Send;
+    fn save_snapshot(
+        &self,
+        snapshot: SnapshotData,
+    ) -> impl Future<Output = Result<(), StorageError>> + Send;
 }
 
 /// Snapshot data for transfer between nodes (§5).

consensus/cloud9-raft-io/src/transport.rs

@@ -5,8 +5,8 @@
 
 use std::future::Future;
 
-use cloud9_raft::raft::Message;
 use cloud9_raft::NodeId;
+use cloud9_raft::raft::Message;
 use thiserror::Error;
 
 /// Errors from transport operations.
@@ -58,7 +58,10 @@ pub trait Transport: Send + Sync {
     ///
     /// Called when configuration changes. The transport should establish
     /// connections to new nodes and may close connections to removed nodes.
-    fn update_peers(&self, peers: &[NodeId]) -> impl Future<Output = Result<(), TransportError>> + Send;
+    fn update_peers(
+        &self,
+        peers: &[NodeId],
+    ) -> impl Future<Output = Result<(), TransportError>> + Send;
 }
 
 #[cfg(test)]

consensus/cloud9-raft/src/lib.rs

@@ -1,6 +1,14 @@
 #![forbid(unsafe_code)]
 #![deny(clippy::unwrap_used, clippy::expect_used)]
-#![cfg_attr(any(test, doctest), allow(clippy::unwrap_used, clippy::expect_used))]
+#![cfg_attr(
+    any(test, doctest),
+    allow(
+        clippy::unwrap_used,
+        clippy::expect_used,
+        clippy::panic,
+        clippy::cast_possible_truncation
+    )
+)]
 
 //! Consensus drivers for Cloud9 clusters.
 //!