raft4r 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: deb0a7edb9cbae2e5d2031e35bc7bd7ffc4e5c89
+  data.tar.gz: e14075c2586165f5b047faca7c0428ac8ac564cc
+SHA512:
+  metadata.gz: 47417328d1a49738d41ed689de1feebf65bdab7ccd070cef7739e6faf8999cc452467d3d8d7fe4c0e261205e70ab739d8e478856ecd982fab05f98d137ef60cf
+  data.tar.gz: 69c4f7b8ce64706b9a4c5f8c8494009c81a53906ccafe4aa79823e2fa9f959d3440dbbe9a5429e002166db691eab794c240c52321666c3cc6dc32188680724b4

data/.gitignore

@@ -0,0 +1,4 @@
+.bundle
+Gemfile.lock
+*.swp
+*.log

data/AUTHORS

@@ -0,0 +1 @@
+Yuheng Chen <chyh1990@gmail.com>

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2014-2015 Yuheng Chen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,2 @@
+Raft4r
+==========

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+	  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test

data/bin/fsm_tool.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+require 'raft4r'
+
+dsl = Raft4r::FSMDrawer.new
+dsl.instance_eval File.read(ARGV[0]), ARGV[0]
+#dsl.dump
+puts dsl.to_dot
+

data/bin/raft_server.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require 'raft4r'
+require 'yaml'
+
+config = YAML.load(File.open('config/raft_cluster.yml').read)
+server = Raft4r::RaftServer.new config, ARGV[0]
+server.start_loop

data/config/raft_cluster.yml

@@ -0,0 +1,21 @@
+n1:
+        bind: 127.0.0.1
+        port: 7701
+n2:
+        bind: 127.0.0.1
+        port: 7702
+n3:
+        bind: 127.0.0.1
+        port: 7703
+n4:
+        bind: 127.0.0.1
+        port: 7704
+n5:
+        bind: 127.0.0.1
+        port: 7705
+n6:
+        bind: 127.0.0.1
+        port: 7706
+n7:
+        bind: 127.0.0.1
+        port: 7707

data/examples/example.fsm

@@ -0,0 +1,32 @@
+def helper
+	puts "helper"
+end
+
+init :init
+state :init do
+	enter do
+		@t = 0
+	end
+	trigger :t1 do
+		helper
+		goto :done
+	end
+	trigger :t2 do |arg|
+		@t = arg
+		goto :s1
+	end
+end
+
+state :done do
+	enter do
+		@t = 1
+	end
+end
+
+state :s1 do
+	trigger :t3 do
+		goto :done
+	end
+end
+
+# vim: set ft=ruby:

data/examples/rpc_client.rb

@@ -0,0 +1,14 @@
+require 'raft4r'
+require 'socket'
+
+EM.run {
+	c = Raft4r::RPC::EMRPCClient.new '127.0.0.1', 7711, "n1"
+
+	10.times {
+		c.AppendEntries :help do |resp|
+			p resp
+			EM.stop
+		end
+	}
+}
+

data/lib/raft4r.rb

@@ -0,0 +1,275 @@
+require 'delegate'
+require 'logger'
+require 'raft4r/rpc_base.rb'
+require 'raft4r/fsm.rb'
+
+module Raft4r
+	VERSION = '0.1.0'
+	LOGGER = Logger.new STDERR
+
+	RaftCluster = Struct.new :config, :conn
+	LogEntry = Struct.new :term, :log
+	class RaftHandler < FSM
+		#HEARTBEAT_TIMEOUT = 5
+		#HEARTBEAT_TIMEOUT = 3
+		#REELECT_TIMEOUT_MAX = 0.4
+		ELECTION_TIMEOUT_MIN_MS = 2000
+		HEARTBEAT_PER_TIMEOUT = 3
+		attr_reader :node_id, :config
+
+		include RPC::RPCMachine
+		def initialize config, node_id
+			@config = config
+			@node_id = node_id
+			@node_config = @config[node_id]
+
+			@last_heartbeat = 0
+			@cluster = {}
+			
+			# XXX debug only
+			@election_timeout = (ELECTION_TIMEOUT_MIN_MS + rand(ELECTION_TIMEOUT_MIN_MS) ) / 1000.0
+			# persistent state
+			@current_term = 0
+			@vote_for = nil
+			@log = []
+
+			@log << LogEntry.new(@current_term, nil)
+
+			# volatile states
+			@commit_index = 0
+			@last_applied = 0
+
+			# leader volatile
+			@next_index = []
+			@match_index = []
+
+			# vote state
+			@get_votes = {}
+			@current_leader = nil
+
+			create_fsm
+		end
+
+		def on_init
+			@config.each {|k,v|
+				next if k == @node_id
+				c = RaftCluster.new v, RPC::EMRPCClient.new(v['bind'], v['port'], @node_id)
+				@cluster[k] = c
+			}
+			info "init: election_timeout #{@election_timeout}s"
+			#p @cluster
+			EM::PeriodicTimer.new(5) { print_state }
+
+			# reset FSM
+			reset
+		end
+
+		private
+		def create_fsm
+			init :follower
+			state :follower do
+				enter do
+					info "become follower"
+					reset_election_timer
+				end
+
+				trigger :election_timeout do
+					info "election timout by follower"
+					goto :candidate
+				end
+
+				trigger [:discover_higher_term, :discover_current_leader] do
+					# do nothing
+				end
+			end
+
+			state :candidate do
+				enter do
+					info "become candidate"
+					reset_election_timer
+					start_new_election
+					@current_leader = nil
+				end
+
+				trigger :election_timeout do
+					info "election timout by candidate"
+					start_new_election
+				end
+
+				trigger [:discover_higher_term, :discover_current_leader] do
+					goto :follower
+				end
+
+				trigger :get_majority do
+					goto :leader
+				end
+			end
+
+			state :leader do
+				enter do
+					info 'become leader'
+					@current_leader = @node_id
+					on_timer_heartbeat
+					@heartbeat_timer = EM::PeriodicTimer.new(ELECTION_TIMEOUT_MIN_MS / 1000.0 / HEARTBEAT_PER_TIMEOUT) { on :heartbeat_timer }
+
+				end
+
+				trigger :election_timeout do
+					# do nothing
+				end
+
+				trigger :heartbeat_timer do
+					on_timer_heartbeat
+				end
+
+				trigger :discover_higher_term do
+					goto :follower
+				end
+
+				leave do
+					@heartbeat_timer.cancel
+				end
+			end
+		end
+
+		def info str
+			LOGGER.info "#{@node_id}: #{str}"
+		end
+
+		def print_state
+			info "State: #{current_state}, leader: #{@current_leader}, term: #{@current_term}"
+		end
+
+		def set_term term
+			@current_term = term
+			@vote_for = nil
+			@get_votes = {}
+			#reset_election_timer
+			info "set term to #{@current_term}"
+		end
+
+		def reset_election_timer
+			@election_timer.cancel if @election_timer
+			@election_timer = EM::PeriodicTimer.new(@election_timeout) { on :election_timeout }
+		end
+
+		def on_vote node_id
+			@get_votes[node_id] = true
+			if @get_votes.size > @cluster.size / 2
+				info "get majority"
+				on :get_majority
+			end
+		end
+
+		def start_new_election
+			fail 'ILLEGAL STATE' unless current_state == :candidate
+			info "start new election"
+			# no leader...
+			@current_leader = nil
+			@get_votes = 0
+			# reset election timer
+
+			set_term @current_term + 1
+			# random step back
+			#timeout = (100 + rand(200)) / 1000.0
+			# vote for self
+			@vote_for = @node_id
+			on_vote @node_id
+
+			@cluster.each {|k,v|
+				# XXX what if get reply in the future?
+				v.conn.RequestVote @current_term, @node_id, @log.size, @log.last.term do |req, resp|
+					next unless current_state == :candidate
+					info "Get vote from #{k}: #{resp.response[1]}"
+					on_vote resp.node_id if resp.response[1]
+				end
+			}
+		end
+
+		def on_timer_heartbeat
+			return unless current_state == :leader
+
+			#print_state
+			@cluster.each { |k,v|
+				# TODO
+				v.conn.AppendEntries @current_term, @node_id, 0, 0, nil, 0
+			}
+
+		end
+
+		def on_rpc_common req
+			if req.arguments[0] > @current_term
+				set_term req.arguments[0]
+				on :discover_higher_term
+			end
+		end
+
+		public
+		# on RPC request
+		def AppendEntries req
+			#info "AppendEntries from #{req.node_id}"
+			# check req
+			return [@current_term, false] if req.arguments[0] < @current_term
+			on_rpc_common req
+			# heartbeat from new leader
+			if req.arguments[0] == @current_term
+				# if state is candidate
+				on :discover_current_leader
+			end
+
+			reset_election_timer
+			@current_leader = req.node_id
+			return [@current_term, true]
+		end
+
+		def RequestVote req
+			info "RequestVote from #{req.node_id}"
+			return [@current_term, false] if req.arguments[0] < @current_term
+			on_rpc_common req
+
+			# or @vote_for == candidateId??
+			candidateId = req.arguments[1]
+			if @vote_for.nil? || @vote_for == candidateId
+				# if candidate is 'up-to-date'
+				vote = false
+				if @log.last.term < req.arguments[3]
+					vote = true
+				elsif @log.last.term == req.arguments[3]
+					# longer log wins
+					vote = req.arguments[2] >= @log.size
+				end
+				if vote
+					info "Vote for #{candidateId}"
+					@vote_for = candidateId
+					reset_election_timer
+					return [@current_term, true]
+				else
+					return [@current_term, false]
+				end
+			else
+				# this node already voted
+				return [@current_term, false]
+			end
+		end
+	end
+
+
+	class RaftServer
+		# XXX handle cluster reconfig
+		def initialize config, node_id
+			s = config[node_id]
+			raise 'Node not found' unless s
+
+			@config = config
+			@node_id = node_id
+			@addr = s['bind']
+			@port = s['port']
+			LOGGER.info "Node: #{@node_id}, #{@addr}:#{@port}"
+		end
+		def start_loop
+			LOGGER.info "Start RaftServer #{@addr}:#{@port}..."
+			RPC::EMRPCServer.start_server @addr, @port, RaftHandler.new(@config, @node_id)
+		end
+	end
+end
+

data/lib/raft4r/fsm.rb

@@ -0,0 +1,134 @@
+module Raft4r
+	class StateScope
+		attr_reader :name, :triggers, :onenter, :onleave
+		def initialize name
+			@name = name
+			@triggers = {}
+		end
+
+		def trigger t, &block
+			t = [t] if !(Array === t)
+			t.each {|e|
+				raise 'trigger already exists' if @triggers[e]
+				@triggers[e] = block
+			}
+		end
+
+		def enter &block
+			@onenter = block
+		end
+
+		def leave &block
+			@onleave = block
+		end
+	end
+
+	class FSM
+		def initialize &block
+			self.instance_eval(&block) if block_given?
+		end
+
+		def current
+			curr = @fsm_states[@fsm_current]
+			raise "Invalid state #{s}" unless curr
+			curr
+		end
+
+		def set_current s
+			raise "Invalid new state #{s}" unless @fsm_states[s]
+			@fsm_current = s
+		end
+		private :current, :set_current
+
+		def init st
+			@fsm_states = {}
+			@fsm_current = nil
+			@fsm_init = st
+		end
+
+		def state s, &block
+			raise 'State already exists' if @fsm_states[s]
+			ss = StateScope.new s
+			ss.instance_eval(&block)
+			@fsm_states[s] = ss
+		end
+
+		def on s, *arguments
+			curr = @fsm_states[@fsm_current]
+			if curr.triggers[s]
+				self.instance_exec(*arguments, &curr.triggers[s])
+			else
+				STDERR.puts "State: #{@fsm_current}, trigger #{s} not exists"
+			end
+		end
+
+		def goto s
+			return if s == @current
+			self.instance_eval(&current.onleave) if current.onleave
+			set_current s
+			self.instance_eval(&current.onenter) if current.onenter
+		end
+
+		def reset
+			raise 'No init state' unless @fsm_init
+			set_current @fsm_init
+			self.instance_eval(&current.onenter) if current.onenter
+		end
+
+		def dump
+			p self
+		end
+
+		def current_state
+			@fsm_current
+		end
+	end
+
+	class FSMDrawer < BasicObject
+		def initialize
+			@init = nil
+			@states = {}
+		end
+
+		def init s
+			@init = s
+		end
+
+		def goto s
+			@triggers << s
+		end
+
+		def trigger t, &block
+			@triggers = @curr[t] || []
+			self.instance_eval &block
+			@curr[t] = @triggers
+		end
+
+		def state s, &block
+			@curr = {}
+			self.instance_eval &block
+			@states[s] = @curr
+		end
+
+		def dump
+			::Kernel::p @states
+		end
+
+		def to_dot
+			s = []
+			s << "digraph graphname{"
+			@states.each {|k,v|
+				v.each {|tn, ns|
+					s << "\t#{k} -> #{ns.first} [label=\"#{tn}\"]"
+				}
+			}
+			s << "\t__init__ -> #{@init}"
+			s << "}"
+			s.join("\n")
+		end
+
+		def method_missing(name, *args, &block)
+		end
+	end
+end
+

data/lib/raft4r/rpc_base.rb

@@ -0,0 +1,108 @@
+require 'eventmachine'
+
+module Raft4r
+	module RPC
+		# sender node_id
+		Request = Struct.new :node_id, :req_id, :method, :arguments
+		Response = Struct.new :node_id, :req_id, :code, :response
+
+		class Request
+			def to_id
+				"#{node_id}_#{req_id}"
+			end
+		end
+
+		module RPCMachine
+			def call_method conn, r
+				@req_pool ||= Hash.new
+				# if the machine supports async call,
+				# try it first
+				if self.respond_to? :"Async#{r.method}"
+					@req_pool[r.to_id] = [conn, r]
+					self.__send__ r.method.to_sym, r
+				else
+					v = self.__send__ r.method.to_sym, r
+					p = Marshal.dump Response.new(@node_id, r.req_id, 0, v)
+					conn.send_data p
+				end
+			end
+
+			def response_method req, resp
+				r = @req_pool[req.to_id]
+				return unless r
+				p = Marshal.dump Response.new(@node_id, req.req_id, 0, resp)
+				r[0].send_data p
+				#r[0].close_connection_after_writing
+				@req_pool.delete req.to_id
+				#LOGGER.info req.inspect
+			end
+		end
+
+		class RPCConn < EventMachine::Connection
+			def initialize mach
+				super
+				@mach = mach
+			end
+		
+			def post_init
+				#EM.add_periodic_timer(1) {puts "sec"}
+			end
+
+			def receive_data data
+				r = Marshal.load(data)
+				@mach.call_method self, r
+			end
+		end
+
+		class EMRPCServer
+			def self.start_server addr, port, handler
+				EM.run {
+					handler.on_init if handler.respond_to? :on_init
+					us = EM.open_datagram_socket addr, port, RPCConn, handler
+				}
+			end
+		end
+
+		class RPCClientConn < EventMachine::Connection
+			def initialize h
+				@h = h
+			end
+			def receive_data data
+				resp = Marshal.load(data)
+				req = @h.pending[resp.req_id]
+				return unless req
+				@h.pending.delete resp.req_id
+				req[1].call req[0], resp if req[1]
+			end
+		end
+
+		class EMRPCClient
+			attr_reader :pending
+			RPC_TIMEOUT = 1
+			def initialize addr, port, sender_node_id
+				@addr = addr
+				@port = port
+				@current_reqid = Time.now.to_i + rand(1000)
+				@pending = {}
+				@node_id = sender_node_id
+				@us = EM.open_datagram_socket '127.0.0.1', 0, RPCClientConn, self
+				EM.add_periodic_timer(RPC_TIMEOUT / 2) do
+					now = Time.now
+					s1 = @pending.size
+					@pending.delete_if {|k,v| now - v[2] > RPC_TIMEOUT }
+					timeout_rpcs = s1 - @pending.size
+					LOGGER.warn "timeout rpcs: #{timeout_rpcs}" if timeout_rpcs > 0
+				end
+			end
+
+			def method_missing method_sym, *arguments, &block
+				@current_reqid += 1
+				req = Request.new(@node_id, @current_reqid, method_sym, arguments)
+				pack = Marshal.dump(req)
+				@pending[req.req_id] = [req, block, Time.now]
+				@us.send_datagram pack, @addr, @port
+			end
+		end
+	end
+end
+

data/raft4r.gemspec

@@ -0,0 +1,17 @@
+Gem::Specification.new do |s|
+  s.name        = 'raft4r'
+  s.version     = '0.1.0'
+  s.date        = '2015-01-24'
+  s.summary     = "Ruby Raft implementation"
+  s.description = "Ruby Raft implementation and services based on it."
+  s.authors     = ["Yuheng Chen"]
+  s.email       = 'chyh1990@gmail.com'
+  s.homepage    = 'http://rubygems.org/gems/raft4r'
+  s.license       = 'MIT'
+
+  s.files         = `git ls-files`.split("\n")
+  s.require_paths = ["lib"]
+  
+  s.add_dependency 'eventmachine', '~> 1.0'
+  s.add_development_dependency 'test-unit', '~> 3.0'
+end

data/test/test_fsm.rb

@@ -0,0 +1,56 @@
+require 'test/unit'
+require 'raft4r'
+include Raft4r
+class MyFSM < FSM
+	attr_reader :t
+	def do_helper
+	end
+	def initialize
+		init :init
+		state :init do
+			enter do
+				@t = 0
+			end
+			trigger :t1 do
+				goto :done
+			end
+			trigger :t2 do |arg|
+				do_helper
+				@t = arg
+				goto :s1
+			end
+		end
+
+		state :done do
+			enter do
+				@t = 1
+			end
+		end
+
+		state :s1 do
+			trigger :t3 do
+				goto :done
+			end
+		end
+	end
+end
+
+class FSMTest < Test::Unit::TestCase
+	def setup
+		@fsm = MyFSM.new
+	end
+
+	def test_reset
+		@fsm.reset
+		assert_equal @fsm.t, 0
+		@fsm.on :t1
+		assert_equal @fsm.t, 1
+	end
+
+	def test_on_arguments
+		@fsm.reset
+		assert_equal @fsm.t, 0
+		@fsm.on :t2, 3
+		assert_equal @fsm.t, 3
+	end
+end

data/test/test_raft_server.rb

@@ -0,0 +1,13 @@
+require 'test/unit'
+require 'yaml'
+require 'raft4r'
+
+class RaftServerTest < Test::Unit::TestCase
+	def setup
+		@config = YAML.load(File.open('config/raft_cluster.yml').read)
+	end
+	def test_start_server
+		server = Raft4r::RaftServer.new @config, 'n1'
+		server.start_loop
+	end
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: raft4r
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yuheng Chen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Ruby Raft implementation and services based on it.
+email: chyh1990@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- AUTHORS
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/fsm_tool.rb
+- bin/raft_server.rb
+- config/raft_cluster.yml
+- examples/example.fsm
+- examples/rpc_client.rb
+- lib/raft4r.rb
+- lib/raft4r/fsm.rb
+- lib/raft4r/rpc_base.rb
+- raft4r.gemspec
+- test/test_fsm.rb
+- test/test_raft_server.rb
+homepage: http://rubygems.org/gems/raft4r
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Ruby Raft implementation
+test_files: []