evinrude 0.0.1

data/lib/evinrude/network/protocol.rb

@@ -0,0 +1,69 @@
+require "rbnacl"
+
+class Evinrude
+	class Network
+		module Protocol
+			class VersionError < Error; end
+			class DecryptionError < Error; end
+
+			class MessageTooBigError < Error; end
+
+			private
+
+			def max_message_size
+				@max_message_size ||= begin
+					if File.exist?("/proc/meminfo")
+						File.read("/proc/meminfo").split("\n").map do |l|
+							if l =~ /^MemTotal:\s+(\d+)\s+kB/
+								$1.to_i * 1024 / 10
+							else
+								nil
+							end
+						end.compact.first
+					else
+						100_000_000
+					end
+				end
+			end
+
+			def box(msg)
+				logger.debug(logloc) { "Encrypting message #{msg.inspect} with key #{@keys.first.inspect}" }
+				RbNaCl::SimpleBox.from_secret_key(@keys.first).encrypt(msg)
+			end
+
+			def frame(chunk)
+				"\x00" + encode_length(chunk.length) + chunk
+			end
+
+			def unbox(ciphertext)
+				@keys.each do |k|
+					begin
+						return RbNaCl::SimpleBox.from_secret_key(k).decrypt(ciphertext)
+					rescue RbNaCl::CryptoError
+						# This just means "key failed"; nothing to get upset about
+						logger.debug(logloc) { "Decryption of #{ciphertext.inspect} failed with key #{k.inspect}" }
+					end
+				end
+
+				# ... but if all the keys fail, *that's* something to get upset about
+				raise DecryptionError,
+				      "Received an undecryptable message from #{peer_info}: #{ciphertext[0, 20].inspect}..."
+			end
+
+			def encode_length(i)
+				if i < 128
+					return i.chr
+				else
+					s = ""
+
+					while i > 0
+						s << (i % 256).chr
+						i /= 256
+					end
+
+					(0x80 + s.length).chr + s.reverse
+				end
+			end
+		end
+	end
+end

data/lib/evinrude/node_info.rb

@@ -0,0 +1,35 @@
+class Evinrude
+	class NodeInfo
+		attr_reader :name, :address, :port
+
+		def initialize(address:, port:, name:)
+			@address, @port, @name = address, port, name
+		end
+
+		# It's useful for a NodeInfo to be able to be treated like a hash sometimes.
+		def [](k)
+			case k
+			when :address
+				@address
+			when :port
+				@port
+			when :name
+				@name
+			else
+				raise ArgumentError, "Invalid key #k.inspect}"
+			end
+		end
+
+		def eql?(o)
+			# I know hash equality doesn't mean "equality of hashes", but it amuses
+			# me nonetheless that that is a good way to implement it.
+			[Evinrude::NodeInfo, Hash].include?(o.class) && { address: @address, port: @port, name: @name}.eql?({ address: o[:address], port: o[:port], name: o[:name] })
+		end
+
+		alias :== :eql?
+
+		def hash
+			{ address: @address, port: @port, name: @name }.hash
+		end
+	end
+end

data/lib/evinrude/peer.rb

@@ -0,0 +1,50 @@
+require_relative "./message/append_entries_request"
+
+class Evinrude
+	class Peer
+		attr_reader :conn, :next_index, :match_index, :node_info
+
+		def initialize(conn:, next_index:, node_info:, metrics:)
+			@conn, @next_index, @node_info, @metrics = conn, next_index, node_info, metrics
+			@match_index = 0
+
+			update_metrics
+		end
+
+		def failed_append(last_index = nil)
+			if last_index
+				@next_index = last_index + 1
+			else
+				@next_index = [1, @next_index - 1].max
+			end
+
+			update_metrics
+		end
+
+		def successful_append(last_index)
+			@next_index  = last_index + 1
+			@match_index = last_index
+
+			update_metrics
+		end
+
+		def peer_info
+			conn.peer_info
+		end
+
+		def node_name
+			@node_info.name
+		end
+
+		def rpc(*a)
+			conn.rpc(*a)
+		end
+
+		private
+
+		def update_metrics
+			@metrics.next_index.set(@next_index, labels: { peer: peer_info, node_name: @node_name })
+			@metrics.match_index.set(0, labels: { peer: peer_info, node_name: @node_name })
+		end
+	end
+end

data/lib/evinrude/resolver.rb

@@ -0,0 +1,96 @@
+require "async/dns"
+require "async/dns/system"
+
+class Evinrude
+	class Resolver
+		def initialize
+			@config = Config.new
+			p @config
+			@resolver = Async::DNS::Resolver.new(Async::DNS::System.standard_connections(@config.nameservers))
+		end
+
+		def getaddresses(name)
+			(getresources(name, Resolv::DNS::Resource::IN::AAAA) + getresources(name, Resolv::DNS::Resource::IN::A)).map(&:address).map(&:to_s)
+		end
+
+		def getresources(name, rtype)
+			search_candidates(name).each do |fqdn|
+				response = @resolver.query(fqdn, rtype)
+
+				if response.rcode != Resolv::DNS::RCode::NoError
+					next
+				end
+
+				return response.answer.map { |rr| rr[2] }
+			end
+
+			[]
+		end
+
+		private
+
+		def search_candidates(name)
+			ndots = name.each_char.grep(".").length
+
+			if ndots >= @config.ndots
+				[name] + @config.search_suffixes.map { |ss| "#{name}.#{ss}" }
+			else
+				@config.search_suffixes.map { |ss| "#{name}.#{ss}" }
+			end
+		end
+
+		class Config
+			attr_reader :search_suffixes, :nameservers, :ndots
+
+			def initialize
+				@ndots = 1
+
+				if Object.const_defined?(:Win32)
+					# Taking a punt here
+					@search_suffixes, @nameservers = Win32::Resolv.get_resolv_info
+				else
+					if File.exist?(Async::DNS::System::RESOLV_CONF)
+						parse_resolv_conf(Async::DNS::System::RESOLV_CONF)
+					else
+						raise ArgumentError, "resolver config file #{Async::DNS::System::RESOLV_CONF} does not exist"
+					end
+				end
+			end
+
+			private
+
+			def parse_resolv_conf(filename)
+				@nameservers = []
+
+				File.open(filename) do |fd|
+					fd.each_line do |l|
+						case l
+						when /^domain\s+(.*)$/
+							@search_suffixes = [$1] if @search_suffixes.nil?
+						when /^search\s+(.*)$/
+							@search_suffixes = $1.split(/\s+/)
+						when /^nameserver\s+(.*)$/
+							@nameservers += $1.split(/\s+/)
+						when /^options\s+(.*)$/
+							$1.split(/\s+/).each do |opt|
+								if opt =~ /ndots:(\d+)/
+									@ndots = $1.to_i
+								end
+							end
+						end
+					end
+				end
+
+				if @search_suffixes.nil?
+					@search_suffixes = [Socket.gethostname.split(".", 2)[1].to_s]
+				end
+			end
+		end
+
+		private_constant :Config
+	end
+end
+
+
+
+

data/lib/evinrude/snapshot.rb

@@ -0,0 +1,9 @@
+class Evinrude
+	class Snapshot
+		attr_reader :node_name, :state, :cluster_config, :cluster_config_index, :last_term, :last_index, :last_command_ids
+
+		def initialize(node_name:, state:, cluster_config:, cluster_config_index:, last_term:, last_index:, last_command_ids:)
+			@node_name, @state, @cluster_config, @cluster_config_index, @last_term, @last_index, @last_command_ids = node_name, state, cluster_config, cluster_config_index, last_term, last_index, last_command_ids
+		end
+	end
+end

data/lib/evinrude/state_machine.rb

@@ -0,0 +1,15 @@
+class Evinrude
+	class StateMachine
+		def initialize(**kwargs)
+		end
+
+		def process_command(s)
+		end
+
+		def current_state
+		end
+
+		def snapshot
+		end
+	end
+end

data/lib/evinrude/state_machine/register.rb

@@ -0,0 +1,25 @@
+require_relative "../state_machine"
+
+class Evinrude
+	class StateMachine
+		class Register < StateMachine
+			def initialize(**kwargs)
+				super
+
+				@state = kwargs.fetch(:snapshot, "")
+			end
+
+			def process_command(s)
+				@state = s
+			end
+
+			def current_state
+				@state
+			end
+
+			def snapshot
+				@state
+			end
+		end
+	end
+end

data/smoke_tests/001_single_node_cluster.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+require_relative "./smoke_test_helper"
+
+require "evinrude"
+
+Thread.current.name = "MT"
+
+n = spawn_nodes(1).first
+
+c = n.c
+t = n.t
+
+until c.leader?
+	t.join(0.001)
+end
+
+c.command("bob")
+
+assert_equal c.state, "bob"

data/smoke_tests/002_three_node_cluster.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+
+require_relative "./smoke_test_helper"
+
+require "evinrude"
+
+Thread.current.name = "MT"
+
+nodes = spawn_nodes(3)
+
+n1, n2, n3 = nodes
+
+wait_for_stability(nodes)
+wait_for_consensus(nodes)
+
+assert_equal n1.c.nodes.map(&:name).sort, nodes.map(&:c).map(&:node_name).sort
+assert_equal n2.c.nodes.map(&:name).sort, nodes.map(&:c).map(&:node_name).sort
+assert_equal n3.c.nodes.map(&:name).sort, nodes.map(&:c).map(&:node_name).sort
+
+n1.c.command("bob")
+
+wait_for_consensus(nodes)
+
+assert_equal n1.c.state, "bob"
+assert_equal n2.c.state, "bob"
+assert_equal n3.c.state, "bob"
+
+n2.c.command("fred")
+
+wait_for_consensus(nodes)
+
+assert_equal n1.c.state, "fred"
+assert_equal n2.c.state, "fred"
+assert_equal n3.c.state, "fred"
+
+[Thread.new { n1.c.command("c1") }, Thread.new { n2.c.command("c2") }, Thread.new { n3.c.command("c3") }].each(&:join)
+
+wait_for_consensus(nodes)
+
+val = n1.c.state
+
+assert_equal val, n2.c.state
+assert_equal val, n3.c.state

data/smoke_tests/003_spill.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+require_relative "./smoke_test_helper"
+
+require "evinrude"
+
+Thread.current.name = "MT"
+
+nodes = spawn_nodes(5)
+
+wait_for_stability(nodes)
+wait_for_consensus(nodes)
+
+prev_leader = nodes.find { |n| n.c.leader? }
+prev_leader.t.kill
+nodes.delete(prev_leader)
+default_logger.info(logloc) { "Whacked leader #{prev_leader.t.name} to force election" }
+
+wait_for_stability(nodes)
+
+nodes.find { |n| n.c.follower? }.c.command("bob")
+
+nodes.each do |n|
+	assert_equal n.c.state, "bob", n.t.name
+end

data/smoke_tests/004_stale_read.rb

@@ -0,0 +1,67 @@
+#!/usr/bin/env ruby
+
+require_relative "./smoke_test_helper"
+
+require "evinrude"
+
+Thread.current.name = "MT"
+
+nodes = spawn_nodes(5)
+
+wait_for_stability(nodes)
+wait_for_consensus(nodes)
+
+leader = nodes.find { |n| n.c.leader? }
+
+leader.c.command("bob")
+
+wait_for_consensus(nodes)
+
+chosen_one = nodes.find { |n| n.c.follower? }
+
+assert_equal "bob", chosen_one.c.state
+
+victims = nodes.select { |n| n != leader && n != chosen_one }
+
+victims.each do |v|
+	v.c.singleton_class.prepend(FaultInjector)
+	v.c.pause!(:process_append_entries_request)
+end
+
+# Pop this in a separate thread because, if all goes well, this will block
+cmd_t = Thread.new { Thread.current.name = "CT"; chosen_one.c.command("fred") }
+cmd_t.abort_on_exception = true
+
+# 640 milliseconds ought to be enough for anyone!
+cmd_t.join(0.64)
+
+assert_equal cmd_t.status, "sleep", "Command thread initial wait"
+
+# This should also block
+st_t = Thread.new { Thread.current.name = "ST"; chosen_one.c.state }
+st_t.abort_on_exception = true
+
+st_t.join(0.64)
+
+assert_equal cmd_t.status, "sleep", "Command thread re-check"
+assert_equal st_t.status, "sleep", "State retrieval thread"
+
+# The fact that both of those threads are still waiting patiently indicates
+# that the leader is being queried, and yet it hasn't achieved consensus
+# (because a majority of the cluster is unresponsive).  Now let's open up
+# the floodgates and see what comes out!
+
+victims.each { |v| v.c.unpause!(:process_append_entries_request) }
+
+cmd_t.join(10)
+
+assert_equal cmd_t.status, false, "Command thread completed"
+
+nodes.each do |n|
+	assert_equal "fred", n.c.state, n.t.name
+end
+
+st_t.join(10)
+
+assert_equal st_t.status, false, "State thread completed"
+assert_equal st_t.value, "fred", "State thread gives new value"