raft: become_pre_candidate resets votes

src/lib.rs

@@ -227,8 +227,9 @@ pub mod util;
 pub use self::errors::{Error, Result, StorageError};
 pub use self::log_unstable::Unstable;
 pub use self::progress::{Inflights, Progress, ProgressSet, ProgressState};
-pub use self::raft::{quorum, vote_resp_msg_type, Config, Raft, SoftState, StateRole, INVALID_ID,
-                     INVALID_INDEX};
+pub use self::raft::{
+    quorum, vote_resp_msg_type, Config, Raft, SoftState, StateRole, INVALID_ID, INVALID_INDEX,
+};
 pub use self::raft_log::{RaftLog, NO_LIMIT};
 pub use self::raw_node::{is_empty_snap, Peer, RawNode, Ready, SnapshotStatus};
 pub use self::read_only::{ReadOnlyOption, ReadState};
@@ -248,8 +249,10 @@ pub mod prelude {
     //!
     //! The prelude may grow over time as additional items see ubiquitous use.
 
-    pub use eraftpb::{ConfChange, ConfChangeType, ConfState, Entry, EntryType, HardState, Message,
-                      MessageType, Snapshot, SnapshotMetadata};
+    pub use eraftpb::{
+        ConfChange, ConfChangeType, ConfState, Entry, EntryType, HardState, Message, MessageType,
+        Snapshot, SnapshotMetadata,
+    };
 
     pub use raft::{Config, Raft};
 

src/raft.rs

@@ -828,6 +828,7 @@ impl<T: Storage> Raft<T> {
         // but doesn't change anything else. In particular it does not increase
         // self.term or change self.vote.
         self.state = StateRole::PreCandidate;
+        self.votes = FxHashMap::default();
         info!("{} became pre-candidate at term {}", self.tag, self.term);
     }
 
@@ -937,7 +938,8 @@ impl<T: Storage> Raft<T> {
                 || m.get_msg_type() == MessageType::MsgRequestPreVote
             {
                 let force = m.get_context() == CAMPAIGN_TRANSFER;
-                let in_lease = self.check_quorum && self.leader_id != INVALID_ID
+                let in_lease = self.check_quorum
+                    && self.leader_id != INVALID_ID
                     && self.election_elapsed < self.election_timeout;
                 if !force && in_lease {
                     // if a server receives RequestVote request within the minimum election

src/raw_node.rs

@@ -27,8 +27,10 @@
 
 use std::mem;
 
-use eraftpb::{ConfChange, ConfChangeType, ConfState, Entry, EntryType, HardState, Message,
-              MessageType, Snapshot};
+use eraftpb::{
+    ConfChange, ConfChangeType, ConfState, Entry, EntryType, HardState, Message, MessageType,
+    Snapshot,
+};
 use protobuf::{self, RepeatedField};
 
 use super::errors::{Error, Result};

tests/cases/test_raft.rs

@@ -32,8 +32,10 @@ use std::ops::DerefMut;
 use std::panic::{self, AssertUnwindSafe};
 
 use protobuf::{self, RepeatedField};
-use raft::eraftpb::{ConfChange, ConfChangeType, ConfState, Entry, EntryType, HardState, Message,
-                    MessageType, Snapshot};
+use raft::eraftpb::{
+    ConfChange, ConfChangeType, ConfState, Entry, EntryType, HardState, Message, MessageType,
+    Snapshot,
+};
 use rand;
 
 use raft::storage::MemStorage;
@@ -4132,3 +4134,86 @@ fn test_election_tick_range() {
         assert_eq!(randomized_timeout, cfg.election_tick);
     }
 }
+
+// TestPreVoteWithSplitVote verifies that after split vote, cluster can complete
+// election in next round.
+#[test]
+fn test_prevote_with_split_vote() {
+    let bootstrap = |id| {
+        let mut cfg = new_test_config(id, vec![1, 2, 3], 10, 1);
+        cfg.pre_vote = true;
+        let mut raft = Raft::new(&cfg, new_storage());
+        raft.become_follower(1, INVALID_ID);
+        Interface::new(raft)
+    };
+    let (peer1, peer2, peer3) = (bootstrap(1), bootstrap(2), bootstrap(3));
+
+    let mut network = Network::new(vec![Some(peer1), Some(peer2), Some(peer3)]);
+    network.send(vec![new_message(1, 1, MessageType::MsgHup, 0)]);
+
+    // simulate leader down. followers start split vote.
+    network.isolate(1);
+    network.send(vec![
+        new_message(2, 2, MessageType::MsgHup, 0),
+        new_message(3, 3, MessageType::MsgHup, 0),
+    ]);
+
+    // check whether the term values are expected
+    assert_eq!(
+        network.peers[&2].term, 3,
+        "peer 2 term: {:?}, want {:?}",
+        network.peers[&2].term, 3,
+    );
+    assert_eq!(
+        network.peers[&3].term, 3,
+        "peer 3 term: {:?}, want {:?}",
+        network.peers[&3].term, 3,
+    );
+
+    // check state
+    assert_eq!(
+        network.peers[&2].state,
+        StateRole::Candidate,
+        "peer 2 state: {:?}, want {:?}",
+        network.peers[&2].state,
+        StateRole::Candidate,
+    );
+    assert_eq!(
+        network.peers[&3].state,
+        StateRole::Candidate,
+        "peer 3 state: {:?}, want {:?}",
+        network.peers[&3].state,
+        StateRole::Candidate,
+    );
+
+    // node 2 election timeout first
+    network.send(vec![new_message(2, 2, MessageType::MsgHup, 0)]);
+
+    // check whether the term values are expected
+    assert_eq!(
+        network.peers[&2].term, 4,
+        "peer 2 term: {:?}, want {:?}",
+        network.peers[&2].term, 4,
+    );
+    assert_eq!(
+        network.peers[&3].term, 4,
+        "peer 3 term: {:?}, want {:?}",
+        network.peers[&3].term, 4,
+    );
+
+    // check state
+    assert_eq!(
+        network.peers[&2].state,
+        StateRole::Leader,
+        "peer 2 state: {:?}, want {:?}",
+        network.peers[&2].state,
+        StateRole::Leader,
+    );
+    assert_eq!(
+        network.peers[&3].state,
+        StateRole::Follower,
+        "peer 3 state: {:?}, want {:?}",
+        network.peers[&3].state,
+        StateRole::Follower,
+    );
+}