evinrude 0.0.1

data/lib/evinrude/backoff.rb

@@ -0,0 +1,19 @@
+class Evinrude
+	class Backoff
+		def initialize(slot_time: 0.5, max_slots: 30)
+			@slot_time, @max_slots = slot_time, max_slots
+
+			@fail_count = 0
+		end
+
+		def wait_time
+			@fail_count += 1
+
+			[2 ** @fail_count, @max_slots].min * rand * @slot_time
+		end
+
+		def wait
+			sleep wait_time
+		end
+	end
+end

data/lib/evinrude/cluster_configuration.rb

@@ -0,0 +1,162 @@
+class Evinrude
+	class ClusterConfiguration
+		class TransitionInProgressError < StandardError; end
+
+		include Evinrude::LoggingHelpers
+
+		def initialize(logger:, metrics:)
+			@logger, @metrics = logger, metrics
+			@old = []
+			@new = []
+			@transition_in_progress = false
+			@metrics.joint_configuration.set(0)
+			@m = Mutex.new
+		end
+
+		def transitioning?
+			@transition_in_progress
+		end
+
+		def nodes
+			locked = false
+			unless @m.owned?
+				@m.lock
+				locked = true
+			end
+
+			(@old + @new).uniq
+		ensure
+			@m.unlock if locked
+		end
+
+		def add_node(node_info)
+			@m.synchronize do
+				if @transition_in_progress
+					raise TransitionInProgressError,
+					      "Cannot add a node whilst a config transition is in progress (@old=#{@old.inspect}, @new=#{@new.inspect})"
+				end
+
+				logger.debug(logloc) { "Commencing addition of #{node_info.inspect} to cluster config" }
+
+				# Adding a new node with the same name but, presumably, a different
+				# address and/or port triggers a config change in which the old
+				# address/port is removed and the new address/port is added.
+				existing_node = @old.find { |n| n.name == node_info.name }
+
+				@new = @old + [node_info] - [existing_node].compact
+				if @metrics
+					@metrics.node_count&.set(nodes.length)
+					@metrics.joint_configuration.set(1)
+				end
+				@transition_in_progress = true
+			end
+		end
+
+		def remove_node(node_info, force: false)
+			@m.synchronize do
+				if @transition_in_progress && !force
+					raise TransitionInProgressError,
+					      "Cannot remove a node whilst a config transition is in progress"
+				end
+
+				logger.debug(logloc) { "Commencing #{force ? "forced " : ""}removal of #{node_info.inspect} from cluster config" }
+
+				@new = @old - [node_info]
+				if @metrics
+					@metrics.node_count&.set(nodes.length)
+					@metrics.joint_configuration.set(1)
+				end
+				@transition_in_progress = true
+
+				if force
+					joint_configuration_replicated
+				end
+			end
+		end
+
+		def joint_configuration_replicated
+			unlock = false
+
+			unless @m.owned?
+				@m.lock
+				unlock = true
+			end
+
+			logger.debug(logloc) { "Joint configuration has been replicated" }
+			@old = @new
+			@new = []
+			@transition_in_progress = false
+			@metrics&.joint_configuration&.set(0)
+		ensure
+			@m.unlock if unlock
+		end
+
+		def quorum_met?(present_nodes)
+			@m.synchronize do
+				group_quorum?(@old, present_nodes) && group_quorum?(@new, present_nodes)
+			end
+		end
+
+		def [](id)
+			nodes.find { |n| n.id == id }
+		end
+
+		def encode_with(coder)
+			@m.synchronize do
+				instance_variables.each do |iv|
+					next if %i{@logger @metrics @m}.include?(iv)
+					coder[iv.to_s.sub(/^@/, '')] = instance_variable_get(iv)
+				end
+			end
+		end
+
+		def init_with(coder)
+			@m = Mutex.new
+
+			coder.map.each do |k, v|
+				instance_variable_set(:"@#{k}", v)
+			end
+		end
+
+		def inspect
+			@m.synchronize do
+				"#<#{self.class}:0x#{object_id.to_s(16)} " +
+					instance_variables.map do |iv|
+						next nil if iv == :@logger || iv == :@metrics
+						"#{iv}=#{instance_variable_get(iv).inspect}"
+					end.compact.join(" ")
+			end
+		end
+
+		def logger=(l)
+			if @logger
+				raise ArgumentError, "Logger cannot be changed once set"
+			end
+
+			@logger = l
+		end
+
+		def metrics=(m)
+			if @metrics
+				raise ArgumentError, "Metrics cannot be changed once set"
+			end
+
+			@metrics = m
+		end
+
+		private
+
+		attr_reader :old, :new
+
+		def group_quorum?(group, present_nodes)
+			if group.length < 2
+				# Quorum is automatically met if the group isn't in use (empty) or
+				# if the group is just one (which can only be "us")
+				true
+			else
+				logger.debug(logloc) { "Checking if #{present_nodes.inspect} meets quorum requirement for #{group.inspect}" }
+				(group.select { |m| present_nodes.include?(m) }.length.to_f / group.length.to_f > 0.5).tap { |v| logger.debug(logloc) { v ? "Quorum met" : "Quorum failed" } }
+			end
+		end
+	end
+end

data/lib/evinrude/config_change_queue_entry.rb

@@ -0,0 +1,19 @@
+class Evinrude
+	class ConfigChangeQueueEntry
+		def initialize(msg, conn = nil)
+			@msg, @conn = msg, conn
+		end
+
+		def node_info
+			@msg.node_info
+		end
+
+		def send_successful_reply
+			@conn.send_reply(reply_class.new(success: true))
+		end
+
+		def send_redirect_reply(leader_info)
+			@conn.send_reply(reply_class.new(success: false, leader_info: leader_info))
+		end
+	end
+end

data/lib/evinrude/config_change_queue_entry/add_node.rb

@@ -0,0 +1,13 @@
+require_relative "../config_change_queue_entry"
+
+class Evinrude
+	class ConfigChangeQueueEntry
+		class AddNode < ConfigChangeQueueEntry
+			private
+
+			def reply_class
+				Message::JoinReply
+			end
+		end
+	end
+end

data/lib/evinrude/config_change_queue_entry/remove_node.rb

@@ -0,0 +1,14 @@
+require_relative "../config_change_queue_entry"
+
+class Evinrude
+	class ConfigChangeQueueEntry
+		class RemoveNode < ConfigChangeQueueEntry
+
+			private
+
+			def reply_class
+				Message::NodeRemovalReply
+			end
+		end
+	end
+end

data/lib/evinrude/freedom_patches/range.rb

@@ -0,0 +1,5 @@
+class Range
+	def rand
+		first + Kernel.rand * (last - first)
+	end
+end

data/lib/evinrude/log.rb

@@ -0,0 +1,102 @@
+require "yaml"
+
+class Evinrude
+	class Log
+		include Evinrude::LoggingHelpers
+
+		class TruncationUnderflowError < Error; end
+		class SnapshottedEntryError < Error; end
+
+		attr_reader :snapshot_last_term, :snapshot_last_index
+
+		def initialize(logger:, snapshot_last_term: 0, snapshot_last_index: 0)
+			@logger, @snapshot_last_term, @snapshot_last_index = logger, snapshot_last_term, snapshot_last_index
+
+			@entries = []
+		end
+
+		def append(entry)
+			logger.debug(logloc) { "Appending new entry #{entry.inspect} as ##{@snapshot_last_index + @entries.length + 1}" }
+			@entries << entry
+
+			if @entries.length > 1000
+				old_len = @entries.length
+				snapshotted_entries = @entries[0..499]
+				@entries = @entries[500..]
+				@snapshot_last_index += 500
+				@snapshot_last_term = snapshotted_entries.last.term
+			end
+		end
+
+		def new_snapshot(last_term, last_index)
+			@snapshot_last_term = last_term
+			@snapshot_last_index = last_index
+
+			@entries = []
+		end
+
+		def has_entry?(n)
+			n == 0 || n <= @snapshot_last_index + @entries.length
+		end
+
+		def snapshotted_entry?(n)
+			n > 0 && n <= @snapshot_last_index
+		end
+
+		def last_index
+			@entries.length + @snapshot_last_index
+		end
+
+		def last_entry_term
+			if @entries.empty?
+				@snapshot_last_term
+			else
+				@entries.last.term
+			end
+		end
+
+		def entry_term(n)
+			if n == @snapshot_last_index
+				@snapshot_last_term
+			else
+				self[n]&.term
+			end
+		end
+
+		def entries_from(n)
+			@entries[(n-@snapshot_last_index-1)..] || []
+		end
+
+		# Make the last entry kept in the log the nth.
+		def truncate_to(n)
+			if n > @snapshot_last_index
+				@entries = @entries[0..n-@snapshot_last_index-1]
+			elsif n == @snapshot_last_index
+				@entries = []
+			else
+				raise TruncationUnderflowError,
+				      "Cannot truncate to log entry ##{n}; into the snapshot"
+			end
+		end
+
+		def [](n)
+			if n == 0
+				zeroth_log_entry
+			elsif n <= @snapshot_last_index
+				raise SnapshottedEntryError
+			else
+				@entries[n - @snapshot_last_index - 1]
+			end
+		end
+
+		private
+
+		def zeroth_log_entry
+			@zeroth_log_entry ||= LogEntry::Null.new(term: 0)
+		end
+
+		def snapshot_log_entry
+			@snapshot_log_entry ||= LogEntry::Null.new(term: @snapshot_last_term)
+		end
+	end
+end

data/lib/evinrude/log_entries.rb

@@ -0,0 +1,3 @@
+require_relative "./log_entry/cluster_configuration"
+require_relative "./log_entry/null"
+require_relative "./log_entry/state_machine_command"

data/lib/evinrude/log_entry.rb

@@ -0,0 +1,13 @@
+class Evinrude
+	class LogEntry
+		def self.classes
+			Evinrude::LogEntry.constants.map { |c| Evinrude::LogEntry.const_get(c) }.select { |c| Class === c }
+		end
+
+		attr_reader :term
+
+		def initialize(term:)
+			@term = term
+		end
+	end
+end

data/lib/evinrude/log_entry/cluster_configuration.rb

@@ -0,0 +1,15 @@
+require_relative "../log_entry"
+
+class Evinrude
+	class LogEntry
+		class ClusterConfiguration < LogEntry
+			attr_reader :config
+
+			def initialize(term:, config:)
+				super(term: term)
+
+				@config = config
+			end
+		end
+	end
+end

data/lib/evinrude/log_entry/null.rb

@@ -0,0 +1,6 @@
+class Evinrude
+	class LogEntry
+		class Null < LogEntry
+		end
+	end
+end

data/lib/evinrude/log_entry/state_machine_command.rb

@@ -0,0 +1,13 @@
+class Evinrude
+	class LogEntry
+		class StateMachineCommand < LogEntry
+			attr_reader :command, :id, :node_name
+
+			def initialize(term:, command:, id:, node_name:)
+				super(term: term)
+
+				@command, @id, @node_name = command, id, node_name
+			end
+		end
+	end
+end

data/lib/evinrude/logging_helpers.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "logger"
+
+class Evinrude
+	module LoggingHelpers
+		private
+
+		def logger
+			@logger || Logger.new("/dev/null")
+		end
+
+		def logloc
+			loc = caller_locations.first
+			"#{self.class}##{loc.label}"
+		end
+
+		def log_exception(ex, progname = nil)
+			progname ||= "#{self.class.to_s}##{caller_locations(2, 1).first.label}"
+
+			logger.error(progname) do
+				explanation = if block_given?
+					yield
+				else
+					nil
+				end
+
+				format_backtrace("#{explanation}#{explanation ? ": " : ""}#{ex.message} (#{ex.class})", ex.backtrace)
+			end
+		end
+
+		def with_backtrace(msg)
+			format_backtrace(msg, caller[1..])
+		end
+
+		def format_backtrace(msg, backtrace)
+			([msg] + backtrace).join("\n  ")
+		end
+	end
+end

data/lib/evinrude/message.rb

@@ -0,0 +1,19 @@
+require "yaml"
+
+class Evinrude
+	class Message
+		class ParseError < Evinrude::Error; end
+
+		def self.parse(m)
+			YAML.safe_load(m, permitted_classes: Evinrude::Message.permitted_classes, aliases: true)
+		end
+
+		def self.permitted_classes
+			Evinrude::Message.classes + Evinrude::LogEntry.classes +	[Evinrude::NodeInfo, Evinrude::ClusterConfiguration, Symbol]
+		end
+
+		def self.classes
+			Evinrude::Message.constants.map { |c| Evinrude::Message.const_get(c) }.select { |c| Class === c }
+		end
+	end
+end