raft: rename RoleNode to Node and add Role trait

Author: erikgrinaker

src/raft/node/candidate.rs

@@ -1,6 +1,6 @@
 use super::super::{Address, Event, Message};
 use super::{
-    rand_election_timeout, BoxedNode, DynNode, Follower, Leader, NodeID, RoleNode, Term, Ticks,
+    rand_election_timeout, BoxedNode, DynNode, Follower, Leader, Node, NodeID, Role, Term, Ticks,
 };
 use crate::error::{Error, Result};
 
@@ -29,7 +29,9 @@ impl Candidate {
     }
 }
 
-impl RoleNode<Candidate> {
+impl Role for Candidate {}
+
+impl Node<Candidate> {
     /// Asserts internal invariants.
     fn assert(&mut self) -> Result<()> {
         self.assert_node()?;
@@ -49,7 +51,7 @@ 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<Node<Follower>> {
         assert!(term >= self.term, "Term regression {} -> {}", self.term, term);
 
         if let Some(leader) = leader {
@@ -70,7 +72,7 @@ impl RoleNode<Candidate> {
     }
 
     /// Transition to leader role.
-    fn become_leader(self) -> Result<RoleNode<Leader>> {
+    fn become_leader(self) -> Result<Node<Leader>> {
         info!("Won election for term {}, becoming leader", self.term);
         let peers = self.peers.clone();
         let (last_index, _) = self.log.get_last_index();
@@ -99,7 +101,7 @@ impl RoleNode<Candidate> {
     }
 }
 
-impl DynNode for RoleNode<Candidate> {
+impl DynNode for Node<Candidate> {
     fn id(&self) -> NodeID {
         self.id
     }

src/raft/node/follower.rs

@@ -1,5 +1,7 @@
 use super::super::{Address, Event, Instruction, Message, RequestID, Response};
-use super::{rand_election_timeout, BoxedNode, Candidate, DynNode, NodeID, RoleNode, Term, Ticks};
+use super::{
+    rand_election_timeout, BoxedNode, Candidate, DynNode, Node, NodeID, Role, Term, Ticks,
+};
 use crate::error::{Error, Result};
 
 use ::log::{debug, error, info, warn};
@@ -34,7 +36,9 @@ impl Follower {
     }
 }
 
-impl RoleNode<Follower> {
+impl Role for Follower {}
+
+impl Node<Follower> {
     /// Asserts internal invariants.
     fn assert(&mut self) -> Result<()> {
         self.assert_node()?;
@@ -59,7 +63,7 @@ impl RoleNode<Follower> {
 
     /// Transforms the node into a candidate, by campaigning for leadership in a
     /// new term.
-    fn become_candidate(mut self) -> Result<RoleNode<Candidate>> {
+    fn become_candidate(mut self) -> Result<Node<Candidate>> {
         // Abort any forwarded requests. These must be retried with new leader.
         self.abort_forwarded()?;
 
@@ -70,7 +74,7 @@ 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<Node<Follower>> {
         assert!(term >= self.term, "Term regression {} -> {}", self.term, term);
 
         // Abort any forwarded requests. These must be retried with new leader.
@@ -114,7 +118,7 @@ impl RoleNode<Follower> {
     }
 }
 
-impl DynNode for RoleNode<Follower> {
+impl DynNode for Node<Follower> {
     fn id(&self) -> NodeID {
         self.id
     }

src/raft/node/leader.rs

@@ -1,5 +1,5 @@
 use super::super::{Address, Event, Index, Instruction, Message, Request, Response, Status};
-use super::{BoxedNode, DynNode, Follower, NodeID, RoleNode, Term, Ticks, HEARTBEAT_INTERVAL};
+use super::{BoxedNode, DynNode, Follower, Node, NodeID, Role, Term, Ticks, HEARTBEAT_INTERVAL};
 use crate::error::Result;
 
 use ::log::{debug, info};
@@ -32,7 +32,9 @@ impl Leader {
     }
 }
 
-impl RoleNode<Leader> {
+impl Role for Leader {}
+
+impl Node<Leader> {
     /// Asserts internal invariants.
     fn assert(&mut self) -> Result<()> {
         self.assert_node()?;
@@ -45,7 +47,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<Node<Follower>> {
         assert!(term >= self.term, "Term regression {} -> {}", self.term, term);
         assert!(term > self.term, "Can only become follower in later term");
 
@@ -144,7 +146,7 @@ impl RoleNode<Leader> {
     }
 }
 
-impl DynNode for RoleNode<Leader> {
+impl DynNode for Node<Leader> {
     fn id(&self) -> NodeID {
         self.id
     }

src/raft/node/mod.rs

@@ -52,7 +52,7 @@ pub struct Status {
 /// a trait object, which hides the internal node state. This is more
 /// ergonomic, for two reasons:
 ///
-/// - It allows  use as "node = node.step()?" across typestate transitions (e.g.
+/// - It allows use as "node = node.step()?" across typestate transitions (e.g.
 ///   candidate to leader),
 ///
 /// - It hides generic type parameters (e.g. E: Engine), so they do not
@@ -91,7 +91,7 @@ pub async fn new_node(
 
     let (term, voted_for) = log.get_term()?;
     let mut node =
-        RoleNode { id, peers, term, log, node_tx, state_tx, role: Follower::new(None, voted_for) };
+        Node { id, peers, term, log, node_tx, state_tx, role: Follower::new(None, voted_for) };
     if node.peers.is_empty() {
         info!("No peers specified, starting as leader");
         // If we didn't vote for ourself in the persisted term, bump the
@@ -107,8 +107,11 @@ pub async fn new_node(
     }
 }
 
-// A Raft node with role R
-pub struct RoleNode<R> {
+/// A Raft role -- either leader, follower, or candidate.
+trait Role {}
+
+/// A Raft node with role R.
+struct Node<R: Role> {
     id: NodeID,
     peers: HashSet<NodeID>,
     term: Term,
@@ -118,10 +121,10 @@ pub struct RoleNode<R> {
     role: R,
 }
 
-impl<R> RoleNode<R> {
+impl<R: Role> Node<R> {
     /// Transforms the node into another role.
-    fn become_role<T>(self, role: T) -> RoleNode<T> {
-        RoleNode {
+    fn become_role<T: Role>(self, role: T) -> Node<T> {
+        Node {
             id: self.id,
             peers: self.peers,
             term: self.term,
@@ -137,7 +140,7 @@ impl<R> RoleNode<R> {
         (self.peers.len() as u64 + 1) / 2 + 1
     }
 
-    /// Sends an event
+    /// Sends an event.
     fn send(&self, to: Address, event: Event) -> Result<()> {
         let msg = Message { term: self.term, from: Address::Node(self.id), to, event };
         debug!("Sending {:?}", msg);
@@ -207,17 +210,17 @@ mod tests {
         assert_eq!(msgs, actual);
     }
 
-    fn setup_rolenode() -> Result<(RoleNode<()>, mpsc::UnboundedReceiver<Message>)> {
+    fn setup_rolenode() -> Result<(Node<Follower>, mpsc::UnboundedReceiver<Message>)> {
         setup_rolenode_peers(vec![2, 3])
     }
 
     fn setup_rolenode_peers(
         peers: Vec<NodeID>,
-    ) -> Result<(RoleNode<()>, mpsc::UnboundedReceiver<Message>)> {
+    ) -> Result<(Node<Follower>, mpsc::UnboundedReceiver<Message>)> {
         let (node_tx, node_rx) = mpsc::unbounded_channel();
         let (state_tx, _) = mpsc::unbounded_channel();
-        let node = RoleNode {
-            role: (),
+        let node = Node {
+            role: Follower::new(None, None),
             id: 1,
             peers: HashSet::from_iter(peers),
             term: 1,
@@ -279,17 +282,6 @@ mod tests {
         new_node(1, HashSet::from([2, 3]), log, state.clone(), node_tx).await.unwrap();
     }
 
-    #[test]
-    fn become_role() -> Result<()> {
-        let (node, _) = setup_rolenode()?;
-        let new = node.become_role("role");
-        assert_eq!(new.id, 1);
-        assert_eq!(new.term, 1);
-        assert_eq!(new.peers, HashSet::from([2, 3]));
-        assert_eq!(new.role, "role");
-        Ok(())
-    }
-
     #[test]
     fn quorum() -> Result<()> {
         let quorums = vec![(1, 1), (2, 2), (3, 2), (4, 3), (5, 3), (6, 4), (7, 4), (8, 5)];