Rename Raft RoleNode to NodeState

Author: erikgrinaker

src/raft/node/candidate.rs

@@ -1,5 +1,5 @@
 use super::super::{Address, Event, Message};
-use super::{rand_election_timeout, Follower, Leader, Node, NodeID, RoleNode, Term, Ticks};
+use super::{rand_election_timeout, Follower, Leader, Node, NodeID, NodeState, Term, Ticks};
 use crate::error::{Error, Result};
 
 use ::log::{debug, info, warn};
@@ -27,7 +27,7 @@ impl Candidate {
     }
 }
 
-impl RoleNode<Candidate> {
+impl NodeState<Candidate> {
     /// Asserts internal invariants.
     fn assert(&mut self) -> Result<()> {
         self.assert_node()?;
@@ -47,7 +47,11 @@ impl RoleNode<Candidate> {
     /// Transforms the node into a follower. We either lost the election
     /// and follow the winner, or we discovered a new term in which case
     /// we step into it as a leaderless follower.
-    fn become_follower(mut self, term: Term, leader: Option<NodeID>) -> Result<RoleNode<Follower>> {
+    fn become_follower(
+        mut self,
+        term: Term,
+        leader: Option<NodeID>,
+    ) -> Result<NodeState<Follower>> {
         assert!(term >= self.term, "Term regression {} -> {}", self.term, term);
 
         if let Some(leader) = leader {
@@ -68,7 +72,7 @@ impl RoleNode<Candidate> {
     }
 
     /// Transition to leader role.
-    pub(super) fn become_leader(self) -> Result<RoleNode<Leader>> {
+    pub(super) fn become_leader(self) -> Result<NodeState<Leader>> {
         info!("Won election for term {}, becoming leader", self.term);
         let peers = self.peers.clone();
         let (last_index, _) = self.log.get_last_index();
@@ -170,7 +174,7 @@ mod tests {
 
     #[allow(clippy::type_complexity)]
     fn setup() -> Result<(
-        RoleNode<Candidate>,
+        NodeState<Candidate>,
         mpsc::UnboundedReceiver<Message>,
         mpsc::UnboundedReceiver<Instruction>,
     )> {
@@ -183,7 +187,7 @@ mod tests {
         log.commit(2)?;
         log.set_term(3, Some(1))?;
 
-        let mut node = RoleNode {
+        let mut node = NodeState {
             id: 1,
             peers: HashSet::from([2, 3, 4, 5]),
             term: 3,

src/raft/node/follower.rs

@@ -1,5 +1,5 @@
 use super::super::{Address, Event, Instruction, Message, RequestID, Response};
-use super::{rand_election_timeout, Candidate, Node, NodeID, RoleNode, Term, Ticks};
+use super::{rand_election_timeout, Candidate, Node, NodeID, NodeState, Term, Ticks};
 use crate::error::{Error, Result};
 
 use ::log::{debug, error, info, warn};
@@ -34,7 +34,7 @@ impl Follower {
     }
 }
 
-impl RoleNode<Follower> {
+impl NodeState<Follower> {
     /// Asserts internal invariants.
     fn assert(&mut self) -> Result<()> {
         self.assert_node()?;
@@ -59,7 +59,7 @@ impl RoleNode<Follower> {
 
     /// Transforms the node into a candidate, by campaigning for leadership in a
     /// new term.
-    pub(super) fn become_candidate(mut self) -> Result<RoleNode<Candidate>> {
+    pub(super) fn become_candidate(mut self) -> Result<NodeState<Candidate>> {
         // Abort any forwarded requests. These must be retried with new leader.
         self.abort_forwarded()?;
 
@@ -70,7 +70,11 @@ impl RoleNode<Follower> {
 
     /// Transforms the node into a follower, either a leaderless follower in a
     /// new term or following a leader in the current term.
-    fn become_follower(mut self, leader: Option<NodeID>, term: Term) -> Result<RoleNode<Follower>> {
+    fn become_follower(
+        mut self,
+        leader: Option<NodeID>,
+        term: Term,
+    ) -> Result<NodeState<Follower>> {
         assert!(term >= self.term, "Term regression {} -> {}", self.term, term);
 
         // Abort any forwarded requests. These must be retried with new leader.
@@ -268,17 +272,17 @@ pub mod tests {
     use crate::storage;
     use tokio::sync::mpsc;
 
-    pub fn follower_leader(node: &RoleNode<Follower>) -> Option<NodeID> {
+    pub fn follower_leader(node: &NodeState<Follower>) -> Option<NodeID> {
         node.role.leader
     }
 
-    pub fn follower_voted_for(node: &RoleNode<Follower>) -> Option<NodeID> {
+    pub fn follower_voted_for(node: &NodeState<Follower>) -> Option<NodeID> {
         node.role.voted_for
     }
 
     #[allow(clippy::type_complexity)]
     fn setup() -> Result<(
-        RoleNode<Follower>,
+        NodeState<Follower>,
         mpsc::UnboundedReceiver<Message>,
         mpsc::UnboundedReceiver<Instruction>,
     )> {
@@ -291,7 +295,7 @@ pub mod tests {
         log.commit(2)?;
         log.set_term(3, None)?;
 
-        let node = RoleNode {
+        let node = NodeState {
             id: 1,
             peers: HashSet::from([2, 3, 4, 5]),
             term: 3,
@@ -610,7 +614,7 @@ pub mod tests {
         log.append(2, Some(vec![0x03]))?;
         log.set_term(1, None)?;
 
-        let follower = RoleNode {
+        let follower = NodeState {
             id: 1,
             peers: HashSet::from([2, 3, 4, 5]),
             term: 1,

src/raft/node/leader.rs

@@ -1,5 +1,5 @@
 use super::super::{Address, Event, Index, Instruction, Message, Request, Response, Status};
-use super::{Follower, Node, NodeID, RoleNode, Term, Ticks, HEARTBEAT_INTERVAL};
+use super::{Follower, Node, NodeID, NodeState, Term, Ticks, HEARTBEAT_INTERVAL};
 use crate::error::Result;
 
 use ::log::{debug, info};
@@ -32,7 +32,7 @@ impl Leader {
     }
 }
 
-impl RoleNode<Leader> {
+impl NodeState<Leader> {
     /// Asserts internal invariants.
     fn assert(&mut self) -> Result<()> {
         self.assert_node()?;
@@ -45,7 +45,7 @@ impl RoleNode<Leader> {
 
     /// Transforms the leader into a follower. This can only happen if we find a
     /// new term, so we become a leaderless follower.
-    fn become_follower(mut self, term: Term) -> Result<RoleNode<Follower>> {
+    fn become_follower(mut self, term: Term) -> Result<NodeState<Follower>> {
         assert!(term >= self.term, "Term regression {} -> {}", self.term, term);
         assert!(term > self.term, "Can only become follower in later term");
 
@@ -299,7 +299,7 @@ mod tests {
 
     #[allow(clippy::type_complexity)]
     fn setup() -> Result<(
-        RoleNode<Leader>,
+        NodeState<Leader>,
         mpsc::UnboundedReceiver<Message>,
         mpsc::UnboundedReceiver<Instruction>,
     )> {
@@ -315,7 +315,7 @@ mod tests {
         log.commit(2)?;
         log.set_term(3, Some(1))?;
 
-        let node = RoleNode {
+        let node = NodeState {
             id: 1,
             peers: peers.clone(),
             term: 3,

src/raft/node/mod.rs

@@ -50,9 +50,9 @@ pub struct Status {
 
 /// The local Raft node state machine.
 pub enum Node {
-    Candidate(RoleNode<Candidate>),
-    Follower(RoleNode<Follower>),
-    Leader(RoleNode<Leader>),
+    Candidate(NodeState<Candidate>),
+    Follower(NodeState<Follower>),
+    Leader(NodeState<Leader>),
 }
 
 impl Node {
@@ -70,7 +70,7 @@ impl Node {
         tokio::spawn(driver.drive(state));
 
         let (term, voted_for) = log.get_term()?;
-        let node = RoleNode {
+        let node = NodeState {
             id,
             peers,
             term,
@@ -115,26 +115,26 @@ impl Node {
     }
 }
 
-impl From<RoleNode<Candidate>> for Node {
-    fn from(rn: RoleNode<Candidate>) -> Self {
+impl From<NodeState<Candidate>> for Node {
+    fn from(rn: NodeState<Candidate>) -> Self {
         Node::Candidate(rn)
     }
 }
 
-impl From<RoleNode<Follower>> for Node {
-    fn from(rn: RoleNode<Follower>) -> Self {
+impl From<NodeState<Follower>> for Node {
+    fn from(rn: NodeState<Follower>) -> Self {
         Node::Follower(rn)
     }
 }
 
-impl From<RoleNode<Leader>> for Node {
-    fn from(rn: RoleNode<Leader>) -> Self {
+impl From<NodeState<Leader>> for Node {
+    fn from(rn: NodeState<Leader>) -> Self {
         Node::Leader(rn)
     }
 }
 
 // A Raft node with role R
-pub struct RoleNode<R> {
+pub struct NodeState<R> {
     id: NodeID,
     peers: HashSet<NodeID>,
     term: Term,
@@ -144,10 +144,10 @@ pub struct RoleNode<R> {
     role: R,
 }
 
-impl<R> RoleNode<R> {
+impl<R> NodeState<R> {
     /// Transforms the node into another role.
-    fn become_role<T>(self, role: T) -> RoleNode<T> {
-        RoleNode {
+    fn become_role<T>(self, role: T) -> NodeState<T> {
+        NodeState {
             id: self.id,
             peers: self.peers,
             term: self.term,
@@ -369,16 +369,16 @@ mod tests {
         NodeAsserter::new(node)
     }
 
-    fn setup_rolenode() -> Result<(RoleNode<()>, mpsc::UnboundedReceiver<Message>)> {
+    fn setup_rolenode() -> Result<(NodeState<()>, mpsc::UnboundedReceiver<Message>)> {
         setup_rolenode_peers(vec![2, 3])
     }
 
     fn setup_rolenode_peers(
         peers: Vec<NodeID>,
-    ) -> Result<(RoleNode<()>, mpsc::UnboundedReceiver<Message>)> {
+    ) -> Result<(NodeState<()>, mpsc::UnboundedReceiver<Message>)> {
         let (node_tx, node_rx) = mpsc::unbounded_channel();
         let (state_tx, _) = mpsc::unbounded_channel();
-        let node = RoleNode {
+        let node = NodeState {
             role: (),
             id: 1,
             peers: HashSet::from_iter(peers),