Improve a few Raft assertions

Author: erikgrinaker

src/raft/node/candidate.rs

@@ -2,7 +2,7 @@ use super::super::{Address, Event, Message};
 use super::{rand_election_timeout, Follower, Leader, Node, NodeID, RawNode, Role, Term, Ticks};
 use crate::error::{Error, Result};
 
-use ::log::{debug, info, warn};
+use ::log::{debug, info};
 use std::collections::HashSet;
 
 /// A candidate is campaigning to become a leader.
@@ -134,7 +134,7 @@ impl RawNode<Candidate> {
             Event::ConfirmLeader { .. }
             | Event::AcceptEntries { .. }
             | Event::RejectEntries { .. }
-            | Event::ClientResponse { .. } => warn!("Received unexpected message {:?}", msg),
+            | Event::ClientResponse { .. } => panic!("Received unexpected message {:?}", msg),
         }
         Ok(self.into())
     }

src/raft/node/follower.rs

@@ -2,7 +2,7 @@ use super::super::{Address, Event, Instruction, Log, Message, RequestID, Respons
 use super::{rand_election_timeout, Candidate, Node, NodeID, RawNode, Role, Term, Ticks};
 use crate::error::{Error, Result};
 
-use ::log::{debug, error, info, warn};
+use ::log::{debug, info};
 use std::collections::HashSet;
 use tokio::sync::mpsc;
 
@@ -205,13 +205,14 @@ impl RawNode<Follower> {
                 }
             }
 
+            // We may receive a vote after we lost an election and followed a
+            // different leader. Ignore it.
+            Event::GrantVote => {}
+
             // Forward client requests to the leader, or abort them if there is
             // none (the client must retry).
             Event::ClientRequest { ref id, .. } => {
-                if msg.from != Address::Client {
-                    error!("Received client request from non-client {:?}", msg.from);
-                    return Ok(self.into());
-                }
+                assert_eq!(msg.from, Address::Client, "Client request from non-client");
 
                 let id = id.clone();
                 if let Some(leader) = self.role.leader {
@@ -225,10 +226,7 @@ impl RawNode<Follower> {
 
             // Returns client responses for forwarded requests.
             Event::ClientResponse { id, mut response } => {
-                if !self.is_leader(&msg.from) {
-                    error!("Received client response from non-leader {:?}", msg.from);
-                    return Ok(self.into());
-                }
+                assert!(self.is_leader(&msg.from), "Client response from non-leader");
 
                 // TODO: Get rid of this field, it should be returned at the RPC
                 // server level instead.
@@ -243,8 +241,7 @@ impl RawNode<Follower> {
             // We're not a leader nor candidate in this term, so we shoudn't see these.
             Event::ConfirmLeader { .. }
             | Event::AcceptEntries { .. }
-            | Event::RejectEntries { .. }
-            | Event::GrantVote { .. } => warn!("Received unexpected message {:?}", msg),
+            | Event::RejectEntries { .. } => panic!("Received unexpected message {:?}", msg),
         };
         Ok(self.into())
     }

src/raft/node/leader.rs

@@ -1,4 +1,4 @@
-use super::super::{Address, Event, Index, Instruction, Message, Request, Response, Status};
+use super::super::{Address, Event, Index, Instruction, Message, Request, Status};
 use super::{Follower, Node, NodeID, RawNode, Role, Term, Ticks, HEARTBEAT_INTERVAL};
 use crate::error::Result;
 
@@ -177,15 +177,12 @@ impl RawNode<Leader> {
                 self.state_tx.send(Instruction::Status { id, address: msg.from, status })?
             }
 
-            Event::ClientResponse { id, mut response } => {
-                if let Ok(Response::Status(ref mut status)) = response {
-                    status.server = self.id;
-                }
-                self.send(Address::Client, Event::ClientResponse { id, response })?;
-            }
-
             // Votes can come in after we won the election, ignore them.
             Event::SolicitVote { .. } | Event::GrantVote => {}
+
+            // Leaders never proxy client requests, so we don't expect to see
+            // responses from other nodes.
+            Event::ClientResponse { .. } => panic!("Unexpected message {:?}", msg),
         }
 
         Ok(self.into())