Refactor main loop in raft node of five node example to improve readability

examples/five_mem_node/main.rs

@@ -64,51 +64,54 @@ fn main() {
         let rx_stop_clone = Arc::clone(&rx_stop);
         let logger = logger.clone();
         // Here we spawn the node on a new thread and keep a handle so we can join on them later.
-        let handle = thread::spawn(move || loop {
-            thread::sleep(Duration::from_millis(10));
+        let handle = thread::spawn(move || {
+            // The main loop of the node.
             loop {
-                // Step raft messages.
-                match node.my_mailbox.try_recv() {
-                    Ok(msg) => node.step(msg, &logger),
-                    Err(TryRecvError::Empty) => break,
-                    Err(TryRecvError::Disconnected) => return,
+                thread::sleep(Duration::from_millis(10));
+                loop {
+                    // Step raft messages.
+                    match node.my_mailbox.try_recv() {
+                        Ok(msg) => node.step(msg, &logger),
+                        Err(TryRecvError::Empty) => break,
+                        Err(TryRecvError::Disconnected) => return,
+                    }
                 }
-            }
 
-            let raft_group = match node.raft_group {
-                Some(ref mut r) => r,
-                // When Node::raft_group is `None` it means the node is not initialized.
-                _ => continue,
-            };
+                let raft_group = match node.raft_group {
+                    Some(ref mut r) => r,
+                    // When Node::raft_group is `None` it means the node is not initialized.
+                    _ => continue,
+                };
 
-            if t.elapsed() >= Duration::from_millis(100) {
-                // Tick the raft.
-                raft_group.tick();
-                t = Instant::now();
-            }
+                if t.elapsed() >= Duration::from_millis(100) {
+                    // Tick the raft.
+                    raft_group.tick();
+                    t = Instant::now();
+                }
 
-            // Let the leader pick pending proposals from the global queue.
-            if raft_group.raft.state == StateRole::Leader {
-                // Handle new proposals.
-                let mut proposals = proposals.lock().unwrap();
-                for p in proposals.iter_mut().skip_while(|p| p.proposed > 0) {
-                    propose(raft_group, p);
+                // Let the leader pick pending proposals from the global queue.
+                if raft_group.raft.state == StateRole::Leader {
+                    // Handle new proposals.
+                    let mut proposals = proposals.lock().unwrap();
+                    for p in proposals.iter_mut().skip_while(|p| p.proposed > 0) {
+                        propose(raft_group, p);
+                    }
                 }
-            }
 
-            // Handle readies from the raft.
-            on_ready(
-                raft_group,
-                &mut node.kv_pairs,
-                &node.mailboxes,
-                &proposals,
-                &logger,
-            );
+                // Handle readies from the raft.
+                on_ready(
+                    raft_group,
+                    &mut node.kv_pairs,
+                    &node.mailboxes,
+                    &proposals,
+                    &logger,
+                );
 
-            // Check control signals from the main thread.
-            if check_signals(&rx_stop_clone) {
-                return;
-            };
+                // Check control signals from the main thread.
+                if check_signals(&rx_stop_clone) {
+                    return;
+                };
+            }
         });
         handles.push(handle);
     }

src/lib.rs

@@ -201,7 +201,7 @@ The `Ready` state contains quite a bit of information, and you need to check and
 by one:
 
 1. Check whether `messages` is empty or not. If not, it means that the node will send messages to
-other nodes:
+    other nodes:
 
     ```rust
     # use slog::{Drain, o};
@@ -226,7 +226,7 @@ other nodes:
     ```
 
 2. Check whether `snapshot` is empty or not. If not empty, it means that the Raft node has received
-a Raft snapshot from the leader and we must apply the snapshot:
+    a Raft snapshot from the leader and we must apply the snapshot:
 
     ```rust
     # use slog::{Drain, o};
@@ -254,8 +254,8 @@ a Raft snapshot from the leader and we must apply the snapshot:
     ```
 
 3. Check whether `committed_entries` is empty or not. If not, it means that there are some newly
-committed log entries which you must apply to the state machine. Of course, after applying, you
-need to update the applied index and resume `apply` later:
+    committed log entries which you must apply to the state machine. Of course, after applying, you
+    need to update the applied index and resume `apply` later:
 
     ```rust
     # use slog::{Drain, o};
@@ -310,7 +310,7 @@ need to update the applied index and resume `apply` later:
     after restarting, *it may work but potential log loss may also be ignored silently*.
 
 4. Check whether `entries` is empty or not. If not empty, it means that there are newly added
-entries but have not been committed yet, we must append the entries to the Raft log:
+    entries but have not been committed yet, we must append the entries to the Raft log:
 
     ```rust
     # use slog::{Drain, o};
@@ -335,8 +335,8 @@ entries but have not been committed yet, we must append the entries to the Raft
     ```
 
 5. Check whether `hs` is empty or not. If not empty, it means that the `HardState` of the node has
-changed. For example, the node may vote for a new leader, or the commit index has been increased.
-We must persist the changed `HardState`:
+    changed. For example, the node may vote for a new leader, or the commit index has been increased.
+    We must persist the changed `HardState`:
 
     ```rust
     # use slog::{Drain, o};
@@ -360,7 +360,7 @@ We must persist the changed `HardState`:
     ```
 
 6. Check whether `persisted_messages` is empty or not. If not, it means that the node will send messages to
-other nodes after persisting hardstate, entries and snapshot:
+    other nodes after persisting hardstate, entries and snapshot:
 
     ```rust
     # use slog::{Drain, o};
@@ -385,8 +385,8 @@ other nodes after persisting hardstate, entries and snapshot:
     ```
 
 7. Call `advance` to notify that the previous work is completed. Get the return value `LightReady`
-and handle its `messages` and `committed_entries` like step 1 and step 3 does. Then call `advance_apply`
-to advance the applied index inside.
+    and handle its `messages` and `committed_entries` like step 1 and step 3 does. Then call `advance_apply`
+    to advance the applied index inside.
 
     ```rust
     # use slog::{Drain, o};
@@ -470,8 +470,8 @@ This process is a two-phase process, during the midst of it the peer group's lea
 **two independent, possibly overlapping peer sets**.
 
 > **Note:** In order to maintain resiliency guarantees  (progress while a majority of both peer sets is
-active), it is recommended to wait until the entire peer group has exited the transition phase
-before taking old, removed peers offline.
+> active), it is recommended to wait until the entire peer group has exited the transition phase
+> before taking old, removed peers offline.
 
 */
 

src/quorum/majority.rs

@@ -7,7 +7,7 @@ use std::collections::hash_set::Iter;
 use std::fmt::Formatter;
 use std::mem::MaybeUninit;
 use std::ops::{Deref, DerefMut};
-use std::{cmp, slice, u64};
+use std::{cmp, slice};
 
 /// A set of IDs that uses majority quorums to make decisions.
 #[derive(Clone, Debug, Default, PartialEq, Eq)]

src/raw_node.rs

@@ -218,6 +218,7 @@ impl Ready {
     /// MustSync is false if and only if
     /// 1. no HardState or only its commit is different from before
     /// 2. no Entries and Snapshot
+    ///
     /// If it's false, an asynchronous write of HardState is permissible before calling
     /// [`RawNode::on_persist_ready`] or [`RawNode::advance`] or its families.
     #[inline]

src/storage.rs

@@ -579,7 +579,7 @@ mod test {
             new_entry(5, 5),
             new_entry(6, 6),
         ];
-        let max_u64 = u64::max_value();
+        let max_u64 = u64::MAX;
         let mut tests = vec![
             (
                 2,

src/util.rs

@@ -5,7 +5,6 @@
 
 use std::fmt;
 use std::fmt::Write;
-use std::u64;
 
 use slog::{OwnedKVList, Record, KV};