rgossip 0.1.0

data/README

@@ -0,0 +1,43 @@
+= rgossip
+
+== Description
+
+Basic implementation of a gossip protocol.
+
+This is a porting of Java implementation.
+
+see http://code.google.com/p/gossip-protocol-java/
+
+== Install
+
+gem install rgossip
+
+== Example
+
+  require 'rubygems'
+  require 'rgossip'
+  
+  #RGossip.debug = true
+  #RGossip.porting = 20870 # default: 100870(udp)
+  
+  gossip = RGossip::Client.new ['10.150.174.161', '10.150.185.250', '10.150.174.30']
+  # RGossip::Client#initialize(initial_nodes = [], address = nil,  data = nil)
+  
+  gossip.data = 'node-1'
+  gossip.start
+  #gossip.join
+  
+  loop do
+    case gets
+    when /list/i
+      gossip.each do |address, data|
+        puts "#{address}: #{data}"
+        # (example output)
+        # 10.150.174.161: node-1
+        # 10.150.174.30: node-3
+        # 10.150.185.250: node-2
+      end
+    when /^add\s+(.+)$/
+      gossip.add_node $1
+    end
+  end

data/lib/rgossip/client.rb

@@ -0,0 +1,103 @@
+module RGossip
+  class Client
+    include Enumerable
+
+    attr_reader :node_list
+    attr_reader :dead_list
+    attr_reader :my_node
+
+    def initialize(initial_nodes = [], address = nil,  data = nil)
+      raise 'too large data' if data && data.length > RGossip.bufsiz
+
+      @address = address || IPSocket.getaddress(Socket.gethostname)
+
+      RGossip.log("Initialize Client: initial_nodes=#{initial_nodes.inspect} address: #{@address} data: #{data.inspect}")
+
+      @node_list = Nodes.new
+      @dead_list = Nodes.new
+      @my_node = Node.new(@node_list, @dead_list, @address, data)
+      @my_node.update_timestamp
+      @node_list << @my_node
+
+      initial_nodes.uniq.each do |i|
+        @node_list << Node.new(@node_list, @dead_list, i, nil)
+      end
+    end
+
+    def start
+      return if @running
+      RGossip.log("Start Client: address=#{@address}")
+
+      @gossiper = Gossiper.new(@my_node, @node_list)
+      @receiver = Receiver.new(@my_node, @node_list, @dead_list)
+
+      @node_list.each do |node|
+        if node.address != @my_node.address
+          node.start_timer
+        end
+      end
+
+      @gossiper.start
+      @receiver.start
+      @running = true
+    end
+
+    def stop
+      return unless @running
+      RGossip.log("Stop Client")
+
+      @gossiper.stop
+      @receiver.stop
+      @running = true
+
+      @gossiper = nil
+      @receiver = nil
+    end
+
+    def join
+      @gossiper.join
+      @receiver.join
+    end
+
+    def running?
+      !!@running
+    end
+
+    def data=(v)
+      @node_list.synchronize {
+        @my_node.data = v
+      }
+    end
+
+    def add_node(address)
+      @node_list.synchronize {
+        raise 'node is exist' if @node_list.any? {|i| i.address == address }
+        @node_list << Node.new(@node_list, @dead_list, address, nil)
+      }
+    end
+
+    def delete_node(address)
+      raise 'cannot delete my node' if @my_node.address == address
+
+      @node_list.synchronize {
+        @node_list.reject! do |i|
+          i.address == address
+        end
+      }
+    end
+
+    def clear_dead_list
+      @dead_list.synchronize {
+        @dead_list.clear
+      }
+    end
+
+    def each
+      @node_list.synchronize {
+        @node_list.each do |node|
+          yield([node.address, node.data])
+        end
+      }
+    end
+  end # Client
+end # RGossip

data/lib/rgossip/gossipper.rb

@@ -0,0 +1,57 @@
+class Gossiper
+  @@interval = 0.1
+  def self.interval; @@interval; end
+  def self.interval=(v); @@interval = v; end
+
+  def initialize(my_node, node_list)
+    @my_node = my_node
+    @node_list = node_list
+    @running = true
+  end
+
+  def start
+    RGossip.log("Start Gossiper: interval=#{@@interval}")
+
+    @thread = Thread.start {
+      begin
+        sock = UDPSocket.open
+
+        while @running
+          @node_list.synchronize { gossip(sock) }
+          sleep(@@interval)
+        end
+      ensure
+        sock.close
+      end
+    }
+  end
+
+  def stop
+    RGossip.log("Stop Gossiper")
+
+    @running = false
+  end
+
+  def join
+    @thread.join
+  end
+
+  private
+  def gossip(sock)
+    @my_node.update_timestamp
+
+    dest = @node_list.choice_without(@my_node)
+    return unless dest
+
+    RGossip.log("Gossip: destination=#{dest.address}")
+
+    @node_list.serialize_to_chunks.each do |chunk|
+      begin
+        sock.send(chunk, 0, dest.address, RGossip.port)
+      rescue Exception => e
+        raise e unless RGossip.error_handler
+        RGossip.error_handler.call(e)
+      end
+    end
+  end # Gossiper
+end # RGossip

data/lib/rgossip/node.rb

@@ -0,0 +1,54 @@
+module RGossip
+  class Node
+    attr_reader :address
+    attr_accessor :timestamp
+    attr_accessor :data
+
+    @@lifetime = 10
+    def self.lifetime; @@lifetime; end
+    def self.lifetime=(v); @@lifetime = v; end
+
+    def initialize(node_list, dead_list, address, data, timestamp = nil)
+      @node_list = node_list
+      @dead_list = dead_list
+      @address = address
+      @data = data
+      @timestamp = timestamp || ""
+
+      @timer = Timer.new(@@lifetime) do
+        RGossip.log("Timeout Node: address=#{@address}")
+
+        @node_list.synchronize {
+          @node_list.reject! do |i|
+            i.address == @address
+          end
+        }
+
+        @dead_list.synchronize {
+          @dead_list << self
+        }
+      end
+    end
+
+    def update_timestamp
+      now = Time.now
+      @timestamp = "#{now.tv_sec}#{now.tv_usec}"
+    end
+
+    def to_a
+      [@address, @timestamp, @data]
+    end
+
+    def start_timer
+      RGossip.log("Start Timer: address=#{@address}")
+
+      @timer.start
+    end
+
+    def reset_timer
+      RGossip.log("Reset Timer: address=#{@address}")
+
+      @timer.reset
+    end
+  end # Node
+end # RGossip

data/lib/rgossip/nodes.rb

@@ -0,0 +1,42 @@
+module RGossip
+  class Nodes < Array
+    def initialize(ary = [])
+      super(ary)
+      @mutex = Mutex.new
+    end
+
+    def synchronize
+      @mutex.synchronize { yield }
+    end
+
+    def choice_without(node)
+      node_list = self.select {|i| i.address != node.address }
+      node_list.empty? ? nil : node_list[rand(node_list.size)]
+    end
+
+    def serialize_to_chunks
+      chunks = []
+      nodes = []
+      datasum = ''
+
+      self.sort_by { rand }.each do |node|
+        packed = node.to_a.to_msgpack
+
+        if (datasum + packed).length <= RGossip.bufsiz
+          nodes << node
+          datasum << packed
+        else
+          chunks << nodes.map {|i| i.to_a }.to_msgpack
+          nodes.clear
+          datasum.clear
+        end
+      end
+
+      unless nodes.empty?
+        chunks << nodes.map {|i| i.to_a }.to_msgpack
+      end
+
+      return chunks
+    end
+  end # Nodes
+end # RGossip

data/lib/rgossip/receiver.rb

@@ -0,0 +1,96 @@
+module RGossip
+  class Receiver
+    @@timeout = 3
+    def self.timeout; @@timeout; end
+    def self.timeout=(v); @@timeout = v; end
+
+    def initialize(my_node, node_list, dead_list)
+      @my_node = my_node
+      @node_list = node_list
+      @dead_list = dead_list
+      @running = true
+    end
+
+    def start
+      RGossip.log("Start Receiver: port=#{RGossip.port}")
+
+      @thread = Thread.start {
+        begin
+          sock = UDPSocket.open
+          sock.bind(@my_node.address, RGossip.port)
+
+          while @running
+            receive(sock)
+          end
+        ensure
+          sock.close
+        end
+      }
+    end
+
+    def stop
+      RGossip.log("Stop Receiver")
+
+      @running = false
+    end
+
+    def join
+      @thread.join
+    end
+
+    private
+    def receive(sock)
+      RGossip.log("Receive: timeout=#{@@timeout}")
+
+      begin
+        return unless select([sock], [], [], @@timeout)
+        message, (afam, port, host, ip) = sock.recvfrom(RGossip.bufsiz * RGossip.allowance)
+
+        RGossip.log("Receive from #{host}(#{ip})")
+
+        recv_nodes = MessagePack.unpack(message)
+
+        @node_list.synchronize {
+          merge_lists(recv_nodes)
+        }
+      rescue Exception => e
+        raise e unless RGossip.error_handler
+        RGossip.error_handler.call(e)
+      end
+    end
+
+    def merge_lists(recv_nodes)
+      recv_nodes.each do |address, timestamp, data|
+        next if address == @my_node.address
+
+        if (node = @node_list.find {|i| i.address == address })
+          if timestamp > node.timestamp
+            RGossip.log("Update Node: address=#{address} timestamp=#{timestamp}")
+
+            node.timestamp = timestamp
+            node.data = data
+            node.reset_timer
+          end
+        elsif (index = @dead_list.synchronize { @dead_list.index {|i| i.address == address } })
+          RGossip.log("Come back Node: address=#{address} timestamp=#{timestamp}")
+
+          @dead_list.synchronize {
+            node = @dead_list[index]
+
+            if timestamp > node.timestamp
+              @dead_list.delete_at(index)
+              @node_list << node
+              node.start_timer
+            end
+          }
+        else
+          RGossip.log("Add Node: address=#{address} timestamp=#{timestamp}")
+
+          node = Node.new(@node_list, @dead_list, address, data, timestamp)
+          @node_list << node
+          node.start_timer
+        end
+      end
+    end
+  end # Receiver
+end # RGossip

data/lib/rgossip/timer.rb

@@ -0,0 +1,52 @@
+module RGossip
+  class Timer
+    def initialize(timeout, &block)
+      @timeout = timeout
+      @block = block
+      @mutex = Mutex.new
+      @reset = false
+    end
+
+    def start
+      @mutex.synchronize {
+        if_is_thread_alive? { @thread.kill }
+        @reset = false
+
+        @thread = Thread.start {
+          loop do
+            sleep @timeout
+
+            if @reset
+              @reset = false
+              retry
+            end
+
+            @block.call
+            break
+          end
+        }
+      }
+    end
+
+    def reset
+      @mutex.synchronize {
+        if_is_thread_alive? do
+          begin
+            @reset = true
+            @thread.run
+          ensure
+            @reset = false
+          end
+        end
+      }
+    rescue ThreadError
+    end
+
+    private
+    def if_is_thread_alive?
+      if @thread and @thread.alive?
+        yield
+      end
+    end
+  end # Timer
+end # RGossip

data/lib/rgossip.rb

@@ -0,0 +1,43 @@
+require 'logger'
+require 'msgpack'
+require 'socket'
+require 'thread'
+
+require 'rgossip/client'
+require 'rgossip/node'
+require 'rgossip/nodes'
+require 'rgossip/gossipper'
+require 'rgossip/receiver'
+require 'rgossip/timer'
+
+module RGossip
+  @@port = 10870
+  def self.port; @@port; end
+  def self.port=(v); @@port = v; end
+
+  @@bufsiz = 512
+  def self.bufsiz; @@bufsiz; end
+  def self.bufsiz=(v); @@bufsiz = v; end
+
+  @@allowance = 3
+  def self.allowance; @@allowance; end
+  def self.allowance=(v); @@allowance = v; end
+
+  @@error_handler = lambda {|e| $stderr.puts((["#{e.class}: #{e.message}"] + (e.backtrace || [])).join("\n\tfrom ")) }
+  def self.error_handler; @@error_handler; end
+  def self.error_handler=(v); @@error_handler = v; end
+
+  @@debug = false
+  def self.debug; @@debug; end
+  def self.debug=(v); @@debug = v; end
+
+  @@debug_logger = lambda {|message| $stderr.puts "[#{Time.now.strftime '%x %X'} ##{$$}] #{message}" }
+  def self.debug_logger; @@debug_logger; end
+  def self.debug_logger=(v); @@debug_logger = v; end
+
+  def self.log(message)
+    if self.debug
+      self.debug_logger.call(message)
+    end
+  end
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: rgossip
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- winebarrel
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-22 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: msgpack
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: 
+email: sgwr_dts@yahoo.co.jp
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- lib/rgossip/timer.rb
+- lib/rgossip/gossipper.rb
+- lib/rgossip/client.rb
+- lib/rgossip/receiver.rb
+- lib/rgossip/nodes.rb
+- lib/rgossip/node.rb
+- lib/rgossip.rb
+homepage: https://bitbucket.org/winebarrel/rgossip
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.1
+signing_key: 
+specification_version: 3
+summary: Basic implementation of a gossip protocol. This is a porting of Java implementation. see http://code.google.com/p/gossip-protocol-java/
+test_files: []
+