raft: raft learners should be returned after applyConfChange

src/progress.rs

@@ -68,13 +68,19 @@ impl ProgressSet {
     }
 
     pub fn nodes(&self) -> Vec<u64> {
-        let mut nodes = Vec::with_capacity(self.voters.len() + self.learners.len());
+        let mut nodes = Vec::with_capacity(self.voters.len());
         nodes.extend(self.voters.keys());
-        nodes.extend(self.learners.keys());
         nodes.sort();
         nodes
     }
 
+    pub fn learner_nodes(&self) -> Vec<u64> {
+        let mut ids = Vec::with_capacity(self.learners.len());
+        ids.extend(self.learners.keys());
+        ids.sort();
+        ids
+    }
+
     pub fn get(&self, id: u64) -> Option<&Progress> {
         self.voters.get(&id).or_else(|| self.learners.get(&id))
     }

src/raw_node.rs

@@ -286,6 +286,7 @@ impl<T: Storage> RawNode<T> {
         if cc.get_node_id() == INVALID_ID {
             let mut cs = ConfState::new();
             cs.set_nodes(self.raft.prs().nodes());
+            cs.set_learners(self.raft.prs().learner_nodes());
             return cs;
         }
         let nid = cc.get_node_id();
@@ -296,6 +297,7 @@ impl<T: Storage> RawNode<T> {
         }
         let mut cs = ConfState::new();
         cs.set_nodes(self.raft.prs().nodes());
+        cs.set_learners(self.raft.prs().learner_nodes());
         cs
     }
 

tests/cases/test_raft.rs

@@ -3580,7 +3580,8 @@ fn test_restore_with_learner() {
     assert!(sm.restore(s.clone()));
     assert_eq!(sm.raft_log.last_index(), 11);
     assert_eq!(sm.raft_log.term(11).unwrap(), 11);
-    assert_eq!(sm.prs().nodes().len(), 3);
+    assert_eq!(sm.prs().voters().len(), 2);
+    assert_eq!(sm.prs().learners().len(), 1);
 
     for node in s.get_metadata().get_conf_state().get_nodes() {
         assert!(sm.prs().voters().get(node).is_some());
@@ -3661,7 +3662,7 @@ fn test_add_learner() {
     let mut n1 = new_test_raft(1, vec![1], 10, 1, new_storage());
     n1.add_learner(2);
 
-    assert_eq!(n1.prs().nodes(), vec![1, 2]);
+    assert_eq!(n1.prs().learner_nodes(), vec![2]);
     assert!(n1.prs().learners()[&2].is_learner);
 }
 
@@ -3672,7 +3673,9 @@ fn test_remove_learner() {
     let mut n1 = new_test_learner_raft(1, vec![1], vec![2], 10, 1, new_storage());
     n1.remove_node(2);
     assert_eq!(n1.prs().nodes(), vec![1]);
+    assert_eq!(n1.prs().learner_nodes(), vec![]);
 
     n1.remove_node(1);
     assert!(n1.prs().nodes().is_empty());
+    assert!(n1.prs().learner_nodes().is_empty());
 }

tests/cases/test_raw_node.rs

@@ -269,6 +269,44 @@ fn test_raw_node_propose_add_duplicate_node() {
     assert_eq!(entries[2].take_data(), ccdata2);
 }
 
+#[test]
+fn test_raw_node_propose_add_learner_node() {
+    let s = new_storage();
+    let mut raw_node = new_raw_node(1, vec![], 10, 1, s.clone(), vec![new_peer(1)]);
+    let rd = raw_node.ready();
+    s.wl().append(&rd.entries).expect("");
+    raw_node.advance(rd);
+
+    raw_node.campaign().expect("");
+    loop {
+        let rd = raw_node.ready();
+        s.wl().append(&rd.entries).expect("");
+        if rd.ss.is_some() && rd.ss.as_ref().unwrap().leader_id == raw_node.raft.id {
+            raw_node.advance(rd);
+            break;
+        }
+        raw_node.advance(rd);
+    }
+
+    // propose add learner node and check apply state
+    let cc = conf_change(ConfChangeType::AddLearnerNode, 2);
+    raw_node.propose_conf_change(cc).expect("");
+
+    let rd = raw_node.ready();
+    s.wl().append(&rd.entries).expect("");
+
+    assert!(
+        rd.committed_entries.is_some() && rd.committed_entries.as_ref().unwrap().len() == 1,
+        "should committed the conf change entry"
+    );
+
+    let e = &rd.committed_entries.as_ref().unwrap()[0];
+    let conf_change = protobuf::parse_from_bytes(e.get_data()).unwrap();
+    let conf_state = raw_node.apply_conf_change(&conf_change);
+    assert_eq!(conf_state.nodes, vec![1]);
+    assert_eq!(conf_state.learners, vec![2]);
+}
+
 // test_raw_node_read_index ensures that RawNode.read_index sends the MsgReadIndex message
 // to the underlying raft. It also ensures that ReadState can be read out.
 #[test]