rswim 1.0.0

data/lib/rswim/member/me.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RSwim
+  module Member
+    class Me < Base
+      def initialize(id)
+        super
+        @ack_responder = AckResponder.new(id)
+        @incarnation_number = 0
+        @propagation_count = 0
+      end
+
+      def schedule_ack(member_id)
+        @ack_responder.schedule_ack(member_id)
+      end
+
+      def prepare_output
+        @ack_responder.prepare_output
+      end
+
+      def update_suspicion(status, incarnation_number)
+        if status != :alive && incarnation_number == @incarnation_number
+          @incarnation_number += 1
+
+          # making sure to get priority in being propagated
+          @propagation_count = -10
+        end
+      end
+
+      def increment_propagation_count
+        @propagation_count += 1
+      end
+
+      def prepare_update_entry
+        UpdateEntry.new(@id, :alive, @incarnation_number, @propagation_count)
+      end
+
+      def update(elapsed_seconds); end
+
+      def can_be_pinged?
+        false
+      end
+    end
+  end
+end

data/lib/rswim/member/peer.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RSwim
+  module Member
+    class Peer < Base
+      def initialize(id, node_member_id, member_pool)
+        super(id)
+        @member_pool = member_pool
+        @transmission_state = TransmissionState::Ready.new(id, node_member_id, member_pool)
+        @health_state = HealthState::Alive.new(id, member_pool)
+        @forwarding_state = ForwardingState::Ready.new(id, node_member_id)
+      end
+
+      ## Messages
+
+      # send a ping message to this peer
+      def ping!
+        @transmission_state.enqueue_ping
+      end
+
+      # send ping request to this peer trying to reach target with target_id
+      def ping_request!(target_id)
+        @transmission_state.enqueue_ping_request(target_id)
+      end
+
+      # send a ping message to this peer on behalf of source with source_id
+      def ping_from!(source_id)
+        @transmission_state.enqueue_ping_from(source_id)
+      end
+
+
+      ## Callbacks
+
+      #  call this when you received ack from member
+      def replied_with_ack
+        @transmission_state.member_replied_with_ack
+      end
+
+      def replied_in_time
+        update_suspicion(:alive)
+      end
+
+      def failed_to_reply
+        @health_state.member_failed_to_reply
+      end
+
+
+      ## Commands
+
+      def halt
+        @transmission_state = TransmissionState::Off.new(@id)
+      end
+
+      def forward_ack
+        @forwarding_state.forward_ack_to_member
+      end
+
+      def update(elapsed_seconds)
+        @transmission_state = @transmission_state.advance(elapsed_seconds)
+        @forwarding_state = @forwarding_state.advance(elapsed_seconds)
+        @health_state = @health_state.advance(elapsed_seconds)
+      end
+
+      def prepare_output
+        [@transmission_state, @forwarding_state].flat_map(&:prepare_output)
+      end
+
+      def prepare_update_entry
+        @health_state.update_entry
+      end
+
+      def increment_propagation_count
+        @health_state.increment_propagation_count
+      end
+
+      def update_suspicion(status, incarnation_number=nil)
+        @health_state = @health_state.update_suspicion(status, incarnation_number)
+      end
+
+      def can_be_pinged?
+        @health_state.can_be_pinged?
+      end
+    end
+  end
+end

data/lib/rswim/member/transmission_state/awaiting_ack.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RSwim
+  module Member
+    module TransmissionState
+      class AwaitingAck < Base
+        def initialize(id, node_member_id, member_pool, source_ids, target_ids)
+          super
+          @life_time_seconds = 0
+          @done = false
+        end
+
+        def member_replied_with_ack
+          if @source_ids.include?(@id)
+            @member_pool.member_replied_in_time(@id)
+          end
+          @source_ids.each { |i| @member_pool.forward_ack_to(i) unless i == @id }
+          @source_ids.clear
+          @done = true
+        end
+
+        def advance(elapsed_seconds)
+          @life_time_seconds += elapsed_seconds
+          if @done
+            Ready.new(@id, @node_member_id, @member_pool, @source_ids, @target_ids)
+          elsif @life_time_seconds > R_MS / 1000.0
+            if @source_ids.include?(@id)
+              @member_pool.member_failed_to_reply(@id)
+            end
+            Ready.new(@id, @node_member_id, @member_pool, @source_ids, @target_ids)
+          else
+            self
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rswim/member/transmission_state/base.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RSwim
+  module Member
+    module TransmissionState
+      class Base
+        def initialize(id, node_member_id, member_pool, source_ids, target_ids)
+          @member_pool = member_pool
+          @id = id
+          @node_member_id = node_member_id
+          @source_ids = source_ids
+          @target_ids = target_ids
+          logger.debug("Member with id #{id} entered new state: #{self.class}")
+        end
+
+        def member_replied_with_ack; end
+
+        def advance(_elapsed_seconds)
+          self
+        end
+
+        def prepare_output
+          []
+        end
+
+        def enqueue_ping
+          @source_ids << @id
+        end
+
+        def enqueue_ping_from(source_id)
+          @source_ids << source_id
+        end
+
+        def enqueue_ping_request(target_id)
+          @target_ids << target_id
+        end
+
+        protected
+
+        def logger
+          @_logger ||= begin
+            RSwim::Logger.new("Node #{@node_member_id}", STDERR)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rswim/member/transmission_state/off.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RSwim
+  module Member
+    module TransmissionState
+      class Off < Base
+        def initialize(id)
+          super(id, nil, nil, [], [])
+        end
+
+        def member_replied_with_ack
+          logger.debug("out of order ack from member #{@id}")
+        end
+
+        def advance(_elapsed_seconds)
+          self
+        end
+      end
+    end
+  end
+end

data/lib/rswim/member/transmission_state/ready.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RSwim
+  module Member
+    module TransmissionState
+      class Ready < Base
+        def initialize(id, node_member_id, member_pool, source_ids = [], target_ids = [])
+          super
+        end
+
+        def member_replied_with_ack
+          logger.debug("out of order ack from member #{@id}")
+        end
+
+        def advance(_elapsed_seconds)
+          if !@source_ids.empty?
+            SendingPing.new(@id, @node_member_id, @member_pool, @source_ids, @target_ids)
+          elsif !@target_ids.empty?
+            SendingPingRequest.new(@id, @node_member_id, @member_pool, @source_ids, @target_ids)
+          else
+            self
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rswim/member/transmission_state/sending_ping.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RSwim
+  module Member
+    module TransmissionState
+      class SendingPing < Base
+        def initialize(id, node_member_id, member_pool, source_ids, target_ids)
+          super
+          @done = false
+        end
+
+        def member_replied_with_ack
+          logger.debug("out of order ack from member #{@id}")
+        end
+
+        def advance(_elapsed_seconds)
+          if @done then AwaitingAck.new(@id, @node_member_id, @member_pool, @source_ids, @target_ids)
+          else self
+          end
+        end
+
+        def prepare_output
+          @done = true
+          message = Message.new(@id, @node_member_id, :ping)
+          [message]
+        end
+      end
+    end
+  end
+end

data/lib/rswim/member/transmission_state/sending_ping_request.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RSwim
+  module Member
+    module TransmissionState
+      class SendingPingRequest < Base
+        def initialize(id, node_member_id, member_pool, source_ids, target_ids)
+          super
+          @done = false
+        end
+
+        def member_replied_with_ack
+          logger.debug("out of order ack from member #{@id}")
+        end
+
+        def advance(_elapsed_seconds)
+          if @done then AwaitingAck.new(@id, @node_member_id, @member_pool, @source_ids, @target_ids)
+          else self
+          end
+        end
+
+        def prepare_output
+          @done = true
+          target_id = @target_ids.shift
+          message = Message.new(@id, @node_member_id, :ping_req, target_id: target_id)
+          [message]
+        end
+      end
+    end
+  end
+end

data/lib/rswim/member_pool.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module RSwim
+  class MemberPool
+    def initialize(node_member_id, seed_member_ids)
+      seed_member_ids -= [node_member_id]
+      @node_member_id = node_member_id
+      @me = Member::Me.new(node_member_id)
+      @members = { node_member_id => @me }
+      seed_member_ids.each { |id| member(id) }
+      @subscribers = []
+    end
+
+    def update_member(message)
+      updates = message.payload[:updates]
+      update_suspicions(updates) unless updates.nil?
+
+      sender = member(message.from) # NB: records member if not seen before
+      case message.type
+      when :ping
+        @me.schedule_ack(message.from)
+      when :ack
+        sender.replied_with_ack
+      when :ping_req
+        target_id = message.payload[:target_id]
+        member(target_id).ping_from!(message.from)
+      else
+        raise 'bad message type'
+      end
+    end
+
+    def update_members(elapsed_seconds)
+      @members.values.each { |m| m.update(elapsed_seconds) }
+    end
+
+    def status_report
+      StatusReport.print(@node_member_id, @members)
+    end
+
+    def subscribe(&block)
+      @subscribers << block
+    end
+
+
+    def prepare_output
+      update_entries = @members.map { |_k, member| member.prepare_update_entry }
+                               # .select { |entry| entry.propagation_count < 5 }
+                               .sort_by { |entry| entry.propagation_count } # sort ascending!
+                               .take(15) # TODO: constant
+
+      update_entries.each do |entry|
+        publish(entry.member_id, entry.status) if entry.propagation_count.zero?
+        member(entry.member_id).increment_propagation_count
+      end
+
+      ms = @members.values.flat_map(&:prepare_output)
+      ms.each { |message| message.payload[:updates] = update_entries }
+      ms
+    end
+
+    def send_ping_to_random_healthy_member
+      ms = @members.values.select(&:can_be_pinged?)
+      return if ms.empty?
+
+      index = ms.one? ? 0 : rand(ms.size)
+      member = ms[index]
+      member.ping!
+    end
+
+    def send_ping_request_to_k_members(target_id)
+      @members.inject([]) { |acc, (id, m)| id != target_id && m.can_be_pinged? ? (acc << m) : acc }
+              .take(K)
+              .each { |m| m.ping_request!(target_id) }
+    end
+
+    def forward_ack_to(member_id)
+      member(member_id).forward_ack
+    end
+
+    def halt_member(member_id)
+      member(member_id).halt
+    end
+
+    def remove_member(member_id)
+      raise 'boom' if member_id == @node_member_id
+      @members.delete(member_id)
+    end
+
+    def member_replied_in_time(member_id)
+      member(member_id).replied_in_time
+    end
+
+    def member_failed_to_reply(member_id)
+      member(member_id).failed_to_reply
+    end
+
+    private
+
+    def publish(member_id, status)
+      @subscribers.each { |s| s.call(member_id, status) }
+    end
+
+    def update_suspicions(updates)
+      updates.each do |u|
+        member(u.member_id).update_suspicion(u.status, u.incarnation_number)
+      end
+    end
+
+    def member(id)
+      raise 'boom' if id.nil?
+      @members[id] ||= Member::Peer.new(id, @node_member_id, self)
+    end
+  end
+end