evinrude 0.0.1

data/lib/evinrude/message/append_entries_reply.rb

@@ -0,0 +1,13 @@
+require_relative "../message"
+
+class Evinrude
+	class Message
+		class AppendEntriesReply < Message
+			attr_reader :term, :success, :last_index
+
+			def initialize(term:, success:, last_index: nil)
+				@term, @success, @last_index = term, success, last_index
+			end
+		end
+	end
+end

data/lib/evinrude/message/append_entries_request.rb

@@ -0,0 +1,18 @@
+require_relative "../message"
+require_relative "./append_entries_reply"
+
+class Evinrude
+	class Message
+		class AppendEntriesRequest < Message
+			attr_reader :term, :leader_info, :leader_commit, :prev_log_index, :prev_log_term, :entries
+
+			def initialize(term:, leader_info:, leader_commit:, prev_log_index:, prev_log_term:, entries:)
+				@term, @leader_info, @leader_commit, @prev_log_index, @prev_log_term, @entries = term, leader_info, leader_commit, prev_log_index, prev_log_term, entries
+			end
+
+			def expected_reply_types
+				[AppendEntriesReply]
+			end
+		end
+	end
+end

data/lib/evinrude/message/command_reply.rb

@@ -0,0 +1,13 @@
+require_relative "../message"
+
+class Evinrude
+	class Message
+		class CommandReply < Message
+			attr_reader :success, :leader_info
+
+			def initialize(success:, leader_info: nil)
+				@success, @leader_info = success, leader_info
+			end
+		end
+	end
+end

data/lib/evinrude/message/command_request.rb

@@ -0,0 +1,18 @@
+require_relative "../message"
+require_relative "./command_reply"
+
+class Evinrude
+	class Message
+		class CommandRequest < Message
+			attr_reader :command, :id, :node_name
+
+			def initialize(command:, id:, node_name:)
+				@command, @id, @node_name = command, id, node_name
+			end
+
+			def expected_reply_types
+				[CommandReply]
+			end
+		end
+	end
+end

data/lib/evinrude/message/install_snapshot_reply.rb

@@ -0,0 +1,13 @@
+require_relative "../message"
+
+class Evinrude
+	class Message
+		class InstallSnapshotReply < Message
+			attr_reader :term
+
+			def initialize(term:)
+				@term = term
+			end
+		end
+	end
+end

data/lib/evinrude/message/install_snapshot_request.rb

@@ -0,0 +1,18 @@
+require_relative "../message"
+require_relative "./install_snapshot_reply"
+
+class Evinrude
+	class Message
+		class InstallSnapshotRequest < Message
+			attr_reader :term, :leader_info, :last_included_index, :last_included_term, :data
+
+			def initialize(term:, leader_info:, last_included_index:, last_included_term:, data:)
+				@term, @leader_info, @last_included_index, @last_included_term, @data = term, leader_info, last_included_index, last_included_term, data
+			end
+
+			def expected_reply_types
+				[InstallSnapshotReply]
+			end
+		end
+	end
+end

data/lib/evinrude/message/join_reply.rb

@@ -0,0 +1,13 @@
+require_relative "../message"
+
+class Evinrude
+	class Message
+		class JoinReply < Message
+			attr_reader :success, :leader_info
+
+			def initialize(success:, leader_info: nil)
+				@success, @leader_info = success, leader_info
+			end
+		end
+	end
+end

data/lib/evinrude/message/join_request.rb

@@ -0,0 +1,18 @@
+require_relative "../message"
+require_relative "./join_reply"
+
+class Evinrude
+	class Message
+		class JoinRequest < Message
+			attr_reader :node_info
+
+			def initialize(node_info:)
+				@node_info = node_info
+			end
+
+			def expected_reply_types
+				[JoinReply]
+			end
+		end
+	end
+end

data/lib/evinrude/message/node_removal_reply.rb

@@ -0,0 +1,13 @@
+require_relative "../message"
+
+class Evinrude
+	class Message
+		class NodeRemovalReply < Message
+			attr_reader :success, :leader_info
+
+			def initialize(success:, leader_info: nil)
+				@success, @leader_info = success, leader_info
+			end
+		end
+	end
+end

data/lib/evinrude/message/node_removal_request.rb

@@ -0,0 +1,18 @@
+require_relative "../message"
+require_relative "./node_removal_reply"
+
+class Evinrude
+	class Message
+		class NodeRemovalRequest < Message
+			attr_reader :node_info, :unsafe
+
+			def initialize(node_info:, unsafe: false)
+				@node_info, @unsafe = node_info, unsafe
+			end
+
+			def expected_reply_types
+				[NodeRemovalReply]
+			end
+		end
+	end
+end

data/lib/evinrude/message/read_reply.rb

@@ -0,0 +1,13 @@
+require_relative "../message"
+
+class Evinrude
+	class Message
+		class ReadReply < Message
+			attr_reader :success, :leader_info
+
+			def initialize(success:, leader_info: nil)
+				@success, @leader_info = success, leader_info
+			end
+		end
+	end
+end

data/lib/evinrude/message/read_request.rb

@@ -0,0 +1,18 @@
+require_relative "../message"
+require_relative "./read_reply"
+
+class Evinrude
+	class Message
+		class ReadRequest < Message
+			attr_reader :commit_index
+
+			def initialize(commit_index:)
+				@commit_index = commit_index
+			end
+
+			def expected_reply_types
+				[ReadReply]
+			end
+		end
+	end
+end

data/lib/evinrude/message/vote_reply.rb

@@ -0,0 +1,13 @@
+require_relative "../message"
+
+class Evinrude
+	class Message
+		class VoteReply < Message
+			attr_reader :term, :vote_granted
+
+			def initialize(term:, vote_granted:)
+				@term, @vote_granted = term, vote_granted
+			end
+		end
+	end
+end

data/lib/evinrude/message/vote_request.rb

@@ -0,0 +1,18 @@
+require_relative "../message"
+require_relative "./vote_reply"
+
+class Evinrude
+	class Message
+		class VoteRequest < Message
+			attr_reader :term, :candidate_info, :last_log_index, :last_log_term
+
+			def initialize(term:, candidate_info:, last_log_index:, last_log_term:)
+				@term, @candidate_info, @last_log_index, @last_log_term = term, candidate_info, last_log_index, last_log_term
+			end
+
+			def expected_reply_types
+				[VoteReply]
+			end
+		end
+	end
+end

data/lib/evinrude/messages.rb

@@ -0,0 +1,14 @@
+require_relative "./message/append_entries_reply"
+require_relative "./message/append_entries_request"
+require_relative "./message/command_reply"
+require_relative "./message/command_request"
+require_relative "./message/install_snapshot_reply"
+require_relative "./message/install_snapshot_request"
+require_relative "./message/join_reply"
+require_relative "./message/join_request"
+require_relative "./message/node_removal_reply"
+require_relative "./message/node_removal_request"
+require_relative "./message/read_reply"
+require_relative "./message/read_request"
+require_relative "./message/vote_reply"
+require_relative "./message/vote_request"

data/lib/evinrude/metrics.rb

@@ -0,0 +1,50 @@
+require "prometheus/client"
+require "frankenstein"
+require "frankenstein/remove_time_series"
+
+class Evinrude
+	class Metrics
+		attr_reader :command_execution, :commit_index, :info, :joint_configuration,
+		            :log_entries_persisted, :log_file_size, :log_loaded_from_disk,
+		            :match_index, :messages_received, :next_index, :node_count,
+		            :read_state, :remove_node, :replication_majority, :rpc,
+		            :rpc_exception, :snapshot_file_size, :start_time, :state, :term
+
+		def initialize(registry)
+			@registry = registry
+
+			@command_execution     = Frankenstein::Request.new(:evinrude_command, description: "state machine command", registry: @registry)
+			@commit_index          = get_or_create(:gauge, :evinrude_commit_index, docstring: "The index of the last log entry committed to the state machine")
+			@info                  = get_or_create(:gauge, :evinrude_node_info, docstring: "Basic information about this Evinrude node in labels", labels: %i{node_name listen_address listen_port advertise_address advertise_port})
+			@joint_configuration   = get_or_create(:gauge, :evinrude_joint_configuration_action, docstring: "Whether or not this node is currently using a 'joint' configuration for consensus")
+			@log_entries_persisted = get_or_create(:counter, :evinrude_log_entries_persisted_total, docstring: "How many log entries have been persisted to disk")
+			@log_file_size         = get_or_create(:gauge, :evinrude_log_file_size_bytes, docstring: "The current size of the append-only log file")
+			@log_loaded_from_disk  = get_or_create(:gauge, :evinrude_log_loaded_from_disk, docstring: "Whether (1) or not (0) this Evinrude node was initialized from data on disk")
+			@match_index           = get_or_create(:gauge, :evinrude_follower_match_index, docstring: "The last log index known to be replicated to this follower", labels: %i{peer node_name})
+			@messages_received     = get_or_create(:counter, :evinrude_messages_received_total, docstring: "How many unsolicited (RPC) messages have been received", labels: %i{type})
+			@next_index            = get_or_create(:gauge, :evinrude_follower_next_index, docstring: "The index of the next log entry to be sent to a follower node", labels: %i{peer node_name})
+			@node_count            = get_or_create(:gauge, :evinrude_node_count, docstring: "How many distinct nodes, active or otherwise, are currently in the cluster configuration")
+			@read_state            = Frankenstein::Request.new(:evinrude_read_state, description: "read state check", registry: @registry)
+			@remove_node           = Frankenstein::Request.new(:evinrude_remove_node, description: "remove node request", registry: @registry)
+			@replication_majority  = get_or_create(:gauge, :evinrude_replication_majority_index, docstring: "The last log index that has been replicated to a majority of nodes")
+			@rpc                   = Frankenstein::Request.new(:evinrude_rpc, description: "remote procedure call", registry: @registry, labels: %i{target}, duration_labels: %i{target result})
+			@rpc_exception         = get_or_create(:counter, :evinrude_rpc_to_leader_exceptions_total, docstring: "How many exceptions have been raised whilst trying to do RPCs to the cluster leader", labels: %i{node_name target class})
+			@snapshot_file_size    = get_or_create(:gauge, :evinrude_snapshot_file_size_bytes, docstring: "The current size of the snapshot data file")
+			@start_time            = get_or_create(:gauge, :evinrude_node_start_time, docstring: "The number of seconds since the Unix epoch at which this Evinrude node commenced operation")
+			@state                 = get_or_create(:gauge, :evinrude_node_state, docstring: "The current state of the node; 0=init, 1=candidate, 2=follower, 3=leader")
+			@term                  = get_or_create(:gauge, :evinrude_current_term, docstring: "The current Raft election 'term' that this node is operating in")
+		end
+
+		def clear_peer_metrics
+			[@match_index, @next_index, @replication_majority].each do |metric|
+				metric.values.keys.each { |ls| metric.remove(ls) }
+			end
+		end
+
+		private
+
+		def get_or_create(type, name, docstring:, labels: [])
+			@registry.get(name) || @registry.__send__(type, name, docstring: docstring, labels: labels)
+		end
+	end
+end

data/lib/evinrude/network.rb

@@ -0,0 +1,69 @@
+require "async/io"
+require "socket"
+
+require_relative "./message/join_request"
+require_relative "./network/connection"
+
+class Evinrude
+	class Network
+		class ConnectionTimeoutError < Error; end
+
+		include Evinrude::LoggingHelpers
+
+		def initialize(keys:, logger:, metrics:, listen:, advertise:)
+			@keys, @logger, @metrics, @advertise, @listen = keys, logger, metrics, advertise, listen
+
+			@endpoint = Async::IO::Endpoint.tcp(@listen[:address], @listen[:port])
+		end
+
+		def start
+			@socket = @endpoint.bind.first
+			@socket.listen(Socket::SOMAXCONN)
+			self
+		end
+
+		def advertised_address
+			@advertise[:address] ||
+			(
+				Socket.ip_address_list.select { |a| a.ipv6? && !a.ipv6_loopback? && !a.ipv6_linklocal? }.first ||
+				Socket.ip_address_list.select { |a| a.ipv4? && !a.ipv4_loopback? }.first
+			).ip_address
+		end
+
+		def advertised_port
+			@advertise[:port] ||
+			@socket&.instance_variable_get(:@io)&.local_address&.ip_port
+		end
+
+		def listen_address
+			@listen[:address]
+		end
+
+		def listen_port
+			@listen[:port] == 0 ? advertised_port : @listen[:port]
+		end
+
+		def each_message(&blk)
+			unless @socket
+				bind
+			end
+
+			@socket.listen(Socket::SOMAXCONN)
+
+			@socket.accept_each do |sock|
+				conn = Network::Connection.new(socket: sock, keys: @keys, logger: logger, metrics: @metrics)
+
+				conn.each_message do |msg|
+					blk.call(msg, conn)
+				end
+			end
+		end
+
+		def connect(address:, port:)
+			Connection.connect(address: address, port: port, keys: @keys, logger: logger, metrics: @metrics).tap do |conn|
+				logger.debug(logloc) { "New connection #{conn} to #{address}:#{port}" }
+				yield conn if block_given?
+			end
+		end
+	end
+end

data/lib/evinrude/network/connection.rb

@@ -0,0 +1,144 @@
+require "async/semaphore"
+require "digest/sha2"
+require "yaml"
+
+require_relative "./protocol"
+
+class Evinrude
+	class Network
+		class Connection
+			include Evinrude::LoggingHelpers
+			include Evinrude::Network::Protocol
+
+			class ConnectionError < Error; end
+
+			attr_reader :peer_address, :peer_port
+
+			def self.connect(address:, port:, keys:, logger:, metrics:)
+				backoff = Evinrude::Backoff.new
+
+				begin
+					sock = Async::IO::Endpoint.tcp(address, port).connect
+				rescue Errno::ECONNRESET, Errno::ECONNREFUSED, Errno::ETIMEDOUT => ex
+					logger.info("Evinrude::Network::Connection.connect") { "Could not connect to #{address}:#{port}: #{ex.class}" }
+					raise ConnectionError,
+					      "#{ex.class}"
+				end
+
+				new(socket: sock, logger: logger, metrics: metrics, keys: keys)
+			end
+
+			def initialize(socket:, logger:, metrics:, keys:)
+				@socket, @logger, @metrics = socket, logger, metrics
+
+				@keys = keys.map { |k| Digest::SHA256.digest(k) }
+
+				@sem = Async::Semaphore.new
+
+				@peer_address = @socket.remote_address.ip_address
+				@peer_port    = @socket.remote_address.ip_port
+			end
+
+			def peer_info
+				"#{peer_address}:#{peer_port}"
+			end
+
+			def rpc(msg)
+				@metrics.rpc.measure(target: peer_info) do |labels|
+					begin
+						@sem.acquire do
+							logger.debug(logloc) { "Sending RPC request #{msg.inspect} to #{peer_info}" }
+							begin
+								@socket.write(frame(box(msg.to_yaml)))
+							rescue Errno::EPIPE, IOError, Errno::ECONNRESET => ex
+								logger.debug(logloc) { "Failed to send RPC request to #{peer_info}: #{ex.message} (#{ex.class})" }
+								labels[:result] = ex.class.to_s
+								return nil
+							end
+
+							logger.debug(logloc) { "Request sent; now we wait" }
+
+							begin
+								read_message
+							rescue Protocol::VersionError, Errno::ECONNRESET, Errno::EPIPE, IOError => ex
+								logger.debug(logloc) { "I/O exception #{ex.class} while reading RPC reply" }
+								labels[:result] = ex.class.to_s
+								@socket.close
+								nil
+							end
+						end.tap { labels[:result] = "success" }
+					rescue Async::Wrapper::Cancelled
+						labels[:result] = "cancelled"
+						nil
+					end
+				end
+			end
+
+			def each_message
+				begin
+					loop do
+						@sem.acquire do
+							yield read_message
+						end
+					end
+				rescue Async::Wrapper::Cancelled
+					# This is fine
+					nil
+				rescue Evinrude::Error, SystemCallError, IOError => ex
+					# This is... not so fine, but there's not much we can do about it
+					log_exception(ex) { "Reading message" }
+					@socket.close
+					nil
+				end
+			end
+
+			def send_reply(msg)
+				@socket.write(frame(box(msg.to_yaml)))
+			end
+
+			def close
+				@socket.close
+			end
+
+			def inspect
+				"#<#{self.class}:0x#{object_id.to_s(16)} " +
+					instance_variables.map do |iv|
+						next nil if %i{@logger @metrics @socket}.include?(iv)
+						"#{iv}=#{instance_variable_get(iv).inspect}"
+					end.compact.join(" ")
+			end
+
+			private
+
+			def read_message
+				v = @socket.read(1)
+
+				if v.nil?
+					logger.debug(logloc) { "Connection to #{peer_info} closed" }
+					raise Async::Wrapper::Cancelled
+				end
+
+				unless v == "\x00"
+					raise Protocol::VersionError, "Expected 0, got #{v.inspect}"
+				end
+
+				lenlen = @socket.read(1).ord
+
+				if (lenlen & 0x80) == 0
+					len = lenlen
+				else
+					lenlen &= 0x7f
+					len = @socket.read(lenlen).split(//).inject(0) { |a, c| a * 256 + c.ord }
+				end
+
+				if len > max_message_size
+					raise MessageTooBigError
+				end
+
+				box = @socket.read(len)
+
+				YAML.safe_load(unbox(box), permitted_classes: Message.classes + LogEntry.classes + [NodeInfo, ClusterConfiguration, Symbol], aliases: true)
+			end
+		end
+	end
+end