Implement few election tests

Cargo.toml

@@ -28,3 +28,4 @@ scan_dir = "0.2.0"
 time = "0.1.32"
 rand = "0.3.11"
 libc = "0.1.10"
+matches = "0.1.2"

src/elect/action.rs

@@ -0,0 +1,29 @@
+use time::SteadyTime;
+
+
+#[derive(PartialEq, Eq, Debug)]
+pub enum Action {
+    LeaderPing,
+}
+
+#[derive(PartialEq, Eq, Debug)]
+pub struct ActionList {
+    pub next_wakeup: SteadyTime,
+    pub action: Option<Action>,
+}
+
+impl Action {
+    pub fn and_wait(self, time: SteadyTime) -> ActionList {
+        ActionList {
+            next_wakeup: time,
+            action: Some(self),
+        }
+    }
+    pub fn wait(time: SteadyTime) -> ActionList {
+        ActionList {
+            next_wakeup: time,
+            action: None,
+        }
+    }
+}
+

src/elect/mod.rs

@@ -5,8 +5,10 @@ use time::SteadyTime;
 use time::Timespec;
 
 mod node;
+mod action;
 mod settings;
 mod external;
+#[cfg(test)] mod test_node;
 #[cfg(test)] mod test_mesh;
 #[cfg(test)] mod test_util;
 #[cfg(test)] mod test_split_brain;

src/elect/node.rs

@@ -2,7 +2,8 @@ use rand::{thread_rng, Rng};
 use time::{SteadyTime, Duration};
 
 use super::{Node, Machine, ExternalData};
-use super::settings::start_timeout;
+use super::settings::{start_timeout, HEARTBEAT_INTERVAL};
+use super::action::{Action, ActionList};
 
 
 impl Node {
@@ -15,4 +16,31 @@ impl Node {
             ext: ExternalData::empty(),
         }
     }
+    pub fn time_passed(self, now: SteadyTime) -> (Node, ActionList) {
+        use super::Machine::*;
+        let (machine, action) = match self.machine {
+            Starting { leader_deadline } if leader_deadline <= now => {
+                info!("[{}] Time passed. Electing as a leader", self.id);
+                if self.ext.all_hosts.len() == 0 {
+                    // No other hosts. May safefully become a leader
+                    let next_ping = now +
+                        Duration::milliseconds(HEARTBEAT_INTERVAL);
+                    (Leader { ping_time: next_ping },
+                     Action::LeaderPing.and_wait(next_ping))
+                } else {
+                    unimplemented!();
+                }
+            }
+            Starting { leader_deadline: dline }
+            => (Starting { leader_deadline: dline }, Action::wait(dline)),
+            _ => unimplemented!(),
+        };
+        return (
+            Node {
+                machine: machine,
+                id: self.id,
+                ext: self.ext,
+            },
+            action)
+    }
 }

src/elect/settings.rs

@@ -26,7 +26,7 @@ pub const MAX_MESSAGE_TIMEOUT: i64 = 3000;
 /// system. There is no good reason to wait so long for original Raft. I.e.
 /// it wants to reestablish consistency as fast as possible. But it may be
 /// nicer to keep lower elections for us.
-pub const HEARTBEAT_INTERVAL: u64 = 600;
+pub const HEARTBEAT_INTERVAL: i64 = 600;
 
 
 pub fn start_timeout() -> Duration {

src/elect/test_node.rs

@@ -0,0 +1,30 @@
+//! Tests for the case of single node
+//!
+use time::SteadyTime;
+
+use super::{Node, Machine};
+use super::action::Action;
+use super::test_util::TimeScale;
+
+
+#[test]
+fn test_starting() {
+    let mut scale = TimeScale::new();
+    let node = Node::new("one", scale.now());
+    assert!(matches!(node.machine, Machine::Starting { .. }));
+}
+
+#[test]
+fn test_alone() {
+    let mut scale = TimeScale::new();
+    let node = Node::new("one", scale.now());
+    assert!(matches!(node.machine, Machine::Starting { .. }));
+    scale.advance_ms(100);  // Small time, just continue starting
+    let (node, act) = node.time_passed(scale.now());
+    assert!(matches!(node.machine, Machine::Starting { .. }));
+    assert!(act.action == None);
+    scale.advance_ms(10000);  // Large timeout, should already become a leader
+    let (node, act) = node.time_passed(scale.now());
+    assert!(matches!(node.machine, Machine::Leader { .. }));
+    assert!(act.action == Some(Action::LeaderPing));
+}

src/elect/test_util.rs

@@ -2,12 +2,21 @@ use time::{SteadyTime, Duration};
 
 
 
-struct TimeScale {
+pub struct TimeScale {
     now: SteadyTime,
 }
 
 impl TimeScale {
-    fn advance_ms(&mut self, ms: u64) {
-        self.now += Duration::milliseconds(ms);
+    pub fn new() -> TimeScale {
+        TimeScale {
+            // unfortunately we can't create arbitrary steady time value
+            now: SteadyTime::now(),
+        }
+    }
+    pub fn advance_ms(&mut self, ms: i64) {
+        self.now = self.now +  Duration::milliseconds(ms);
+    }
+    pub fn now(&self) -> SteadyTime {
+        self.now
     }
 }

src/main.rs

@@ -10,6 +10,7 @@ extern crate libc;
 extern crate lua;
 extern crate scan_dir;
 extern crate yaml_rust;
+#[macro_use] extern crate matches;
 #[macro_use] extern crate log;
 #[macro_use] extern crate quick_error;