Make buildable, add initial implementation, abstract the concept of a term

Author: orbitz-other

lib/raft/Makefile

@@ -1,14 +1,14 @@
 CAMLP4=
 
-OCAMLDEP_OPTS=
+OCAMLDEP_OPTS= -package core
 OCAMLC_OPTS=$(OCAMLDEP_OPTS)
 OCAMLOPT_OPTS=$(OCAMLDEP_OPTS)
 
-LIB_MODULES=
+LIB_MODULES=raft.ml
 NON_LIB_MODULES=
 
-BYTE_TARGETS=
-NATIVE_TARGETS=
+BYTE_TARGETS=raft.cma
+NATIVE_TARGETS=raft.cmxa
 
 .PHONY: all test
 

lib/raft/raft.ml

@@ -0,0 +1,80 @@
+module Term = struct
+  type t = Num.num
+
+  let zero      = Num.num_of_int 0
+  let succ      = Num.succ_num
+  let compare   = Num.compare_num
+  let of_string = Num.num_of_string
+  let to_string = Num.string_of_num
+end
+
+module type LOG = sig
+  type elt
+  type t
+
+  val append    : elt -> t -> t option
+  val last_term : t -> Term.t
+end
+
+module type SERVER = sig
+  type t
+
+  val equal : t -> t -> bool
+end
+
+module Make = functor (Server : SERVER) -> functor (Log : LOG) -> struct
+  type 'a t = { voted_for    : Server.t option
+              ; votes        : Server.t list
+              ; me           : Server.t
+              ; servers      : Server.t list
+              ; current_term : Term.t
+              ; log          : Log.t
+              ; leader       : Server.t option
+              }
+
+
+  type error = [ `Bad_term | `Bad_previous ]
+
+  let create ~me ~log servers =
+    { voted_for    = None
+    ; votes        = []
+    ; me           = me
+    ; servers      = servers
+    ; current_term = Log.last_term log
+    ; log          = log
+    ; leader       = None
+    }
+
+  let servers t = t.servers
+
+  let current_term t = t.current_term
+
+  let voted_for t = t.voted_for
+
+  let log t = t.log
+
+  let set_log log t = { t with log = log }
+
+  let leader t = t.leader
+
+  let heartbeat_timeout t = { t with voted_for = None; leader = None }
+
+  let election_timeout t = { t with votes = [] }
+
+  let request_vote server = function
+    | { voted_for = None } as t -> Some { t with voted_for = Some server }
+    | _                         -> None
+
+  let receive_vote server t = { t with votes = server::t.votes }
+
+  let is_now_leader t =
+    if List.length t.votes > (List.length t.servers / 2) then
+      Some { t with votes = []; leader = Some t.me }
+    else
+      None
+
+
+  let receive_log _ _ = failwith "nyi"
+  let append_log _ _ = failwith "nyi"
+
+end

lib/raft/raft.mli

@@ -1,8 +1,19 @@
+module Term : sig
+  type t
+
+  val zero      : t
+  val succ      : t -> t
+  val compare   : t -> t -> int
+  val of_string : string -> t
+  val to_string : t -> string
+end
+
 module type LOG = sig
   type elt
   type t
 
-  val append : elt -> t -> t option
+  val append    : elt -> t -> t option
+  val last_term : t -> Term.t
 end
 
 module type SERVER = sig
@@ -13,29 +24,43 @@ end
 
 module Make : functor (Server : SERVER) -> functor (Log : LOG) -> sig
   type 'a t
+  type error            = [ `Bad_term | `Bad_previous ]
 
-  val create            : Server.t list -> [ `Follower ] t
+  val create            : me:Server.t -> log:Log.t -> Server.t list -> [ `Follower ] t
 
   val servers           : 'a t -> Server.t list
-  val set_servers       : Server.t list -> 'a t -> 'a t
 
-  val current_term      : 'a t -> int
+  val current_term      : 'a t -> Term.t
   val voted_for         : 'a t -> Server.t option
 
   val log               : 'a t -> Log.t
+  val set_log           : Log.t -> 'a t -> 'a t
 
   val leader            : 'a t -> Server.t option
 
-  val next_index        : [ `Leader ] t -> (Server.t * int) list
-  val match_index       : [ `Leader ] t -> (Server.t * int) list
-
+  (*
+   * Triggered when we are a follower and have not heard from the leader
+   * in some timeout period
+   *)
   val heartbeat_timeout : [ `Follower] t -> [ `Candidate ] t
 
+  (*
+   * This set of functions are used during a voting round
+   *
+   * request_vote - A server is requesting a vote from us.  Returns [t option]
+   * if it is granted and None if it is not
+   *
+   * receive_vote - A vote has been requested and received from the server
+   *
+   * is_now_leader - Tests if the current state machine can become a leader.
+   * If so, return it.
+   *)
   val election_timeout  : [ `Candidate ] t -> [ `Candidate ] t
-  val receive_vote      : [ `Candidate ] t -> [ `Candidate ] t
+  val request_vote      : Server.t -> [ `Follower ] t -> [ `Follower ] t option
+  val receive_vote      : Server.t -> [ `Candidate ] t -> [ `Candidate ] t
   val is_now_leader     : [ `Candidate ] t -> [ `Leader ] t option
 
-  val receive_log       : Log.t -> 'a t -> [ `Follower ] t
+  val receive_log       : Log.t -> [ `Candidate | `Follower ] t -> ([ `Follower ] t, [> error ]) Core.Result.t
   val append_log        : Log.t -> [ `Leader ] t -> [ `Leader ] t
 
 end