WIP: election details

src/elect/action.rs

@@ -1,11 +1,13 @@
 use time::SteadyTime;
 
+use super::{Id};
+
 
 #[derive(PartialEq, Eq, Debug)]
 pub enum Action {
     PingAll,
     Vote,
-    ConfirmVote,
+    ConfirmVote(Id),
     PingNew,
 }
 

src/elect/mod.rs

@@ -16,7 +16,7 @@ mod external;
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 struct Id(String);
 
-
+type Capsule = (u64, Message);
 
 #[derive(Clone, Debug)]
 enum Machine {
@@ -34,10 +34,8 @@ enum Message {
     Ping,
     /// Pong message from follower to leader, confirm that node is a leader
     Pong,
-    /// New node or node recover is detected by cantal
-    NodeAdded,
-    /// Node death is detected by cantal
-    NodeRemoved,
+    /// Vote for some node
+    Vote(Id),
 }
 
 #[derive(Clone, Debug)]

src/elect/node.rs

@@ -3,8 +3,8 @@ use std::collections::HashSet;
 use rand::{thread_rng, Rng};
 use time::{SteadyTime, Duration};
 
-use super::{Id, Node, Machine, Message, ExternalData};
-use super::settings::{start_timeout, HEARTBEAT_INTERVAL};
+use super::{Id, Node, Machine, Message, ExternalData, Capsule};
+use super::settings::{start_timeout, election_ivl, HEARTBEAT_INTERVAL};
 use super::action::{Action, ActionList};
 
 
@@ -53,7 +53,38 @@ impl Node {
             },
             action)
     }
-    pub fn message(self, msg: Message) -> (Node, ActionList) {
-        unimplemented!();
+    pub fn message(self, msg: Capsule, now: SteadyTime) -> (Node, ActionList) {
+        use super::Machine::*;
+        use super::Message::*;
+        let (num, data) = msg;
+
+        let (machine, action) = match (self.machine, data) {
+            (Starting { .. }, Ping) => {
+                let dline = now + election_ivl();
+                (Follower { leader_deadline: dline }, Action::wait(dline))
+            }
+            (Starting { leader_deadline: dline }, Pong) => {
+                // This probably means this node was a leader. But there is
+                // no guarantee that no leader has been already elected, so
+                // we just continue work
+                (Starting { leader_deadline: dline }, Action::wait(dline))
+            }
+            (Starting { leader_deadline }, Vote(id)) => {
+                let dline = now + election_ivl();
+                (Voted { peer: id.clone(), election_deadline: dline},
+                 Action::ConfirmVote(id).and_wait(leader_deadline))
+            }
+            (Electing { .. }, _) => unimplemented!(),
+            (Voted { .. }, _) => unimplemented!(),
+            (Leader { .. }, _) => unimplemented!(),
+            (Follower { .. }, _) => unimplemented!(),
+        };
+        return (
+            Node {
+                machine: machine,
+                id: self.id,
+                ext: self.ext,
+            },
+            action)
     }
 }

src/elect/test_node.rs

@@ -2,7 +2,7 @@
 //!
 use time::SteadyTime;
 
-use super::{Node, Machine};
+use super::{Node, Machine, Message};
 use super::action::Action;
 use super::test_util::Environ;
 
@@ -41,3 +41,21 @@ fn test_start_vote() {
     assert!(matches!(node.machine, Machine::Electing { .. }));
     assert!(act.action == Some(Action::Vote));
 }
+
+#[test]
+fn test_vote_approved() {
+    let mut env = Environ::new();
+    let mut node = Node::new("one", env.now());
+    let id = node.id.clone();
+    assert!(matches!(node.machine, Machine::Starting { .. }));
+
+    env.add_another_for(&mut node);
+    env.sleep(10000);  // Large timeout, should start_election
+    let (node, act) = node.time_passed(env.now());
+    assert!(matches!(node.machine, Machine::Electing { .. }));
+    assert!(act.action == Some(Action::Vote));
+
+    let (node, act) = node.message(Message::Vote(id.clone()), env.now());
+    assert!(matches!(node.machine, Machine::Leader { .. }));
+    assert!(act.action == Some(Action::PingAll));
+}