rgossip2 0.1.0

data/README

@@ -0,0 +1,69 @@
+= 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 rgossip2
+
+== Example
+
+  require 'rubygems'
+  require 'rgossip2'
+  
+  gossip = RGossip2.client(
+    :initial_nodes => ['10.150.174.161', '10.150.185.250', '10.150.174.30'],
+    :auth_key => 'onion'
+  )
+  
+  gossip.data = 'Node 01: data'
+  gossip.start
+  #gossip.join
+  
+  loop do
+    case gets
+    when /list/i
+      gossip.each do |address, timestamp, 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
+
+== Command-line interface
+
+  shell> gossip
+  I, [2011-10-30T22:41:05.975084 #2282]  INFO -- : Client is initialized: initial_nodes=[], address=10.142.43.53, data=nil
+  gossip> add ip-10-142-30-230
+  gossip> list
+  IP Address       Timestamp                   Data
+  ---------------  --------------------------  ---------------------------
+  10.142.43.53     2011/10/30 22:41:05.000000
+  10.142.24.230    1970/01/01 09:00:00.000000
+  gossip> start
+  I, [2011-10-30T22:41:22.083898 #2282]  INFO -- : Client is started: address=10.142.43.53
+  I, [2011-10-30T22:41:22.084197 #2282]  INFO -- : Transmission was started: interval=0.1, port=10870
+  I, [2011-10-30T22:41:22.084580 #2282]  INFO -- : Reception is started: port=10870
+  gossip> list
+  IP Address       Timestamp                   Data
+  ---------------  --------------------------  ---------------------------
+  10.142.43.53     2011/10/30 22:41:24.000000
+  10.142.24.230    2011/10/30 22:41:23.000000
+  gossip> data my data
+  gossip> list
+  IP Address       Timestamp                   Data
+  ---------------  --------------------------  ---------------------------
+  10.142.43.53     2011/10/30 22:41:30.000000  my data
+  10.142.24.230    2011/10/30 22:41:30.000000
+

data/bin/gossip

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+$: << File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'rubygems'
+require 'logger'
+require 'optparse'
+require 'readline'
+require 'rgossip2'
+
+options = {:auth_key => 'onion'}
+
+ARGV.options do |opt|
+  opt.on('-i', '--initial-nodes=VAL') {|v| options[:initial_nodes] = (v || '').split(/\s*,\s*/) }
+  opt.on('-a', '--address=VAL')       {|v| options[:address] = v }
+  opt.on('-d', '--data=VAL')          {|v| options[:data] = v }
+  opt.on('-k', '--auth-key=VAL')      {|v| options[:auth_key] = v }
+  opt.parse!
+end
+
+$stdout.sync = true
+$stderr.sync = true
+
+gossip = RGossip2.client(options)
+
+commands = %w(start stop status list data add del clear logger exit)
+Readline.completion_proc = proc {|word| commands.grep(/\A#{Regexp.quote word}/) }
+
+def list_nodes(gossip)
+  puts <<-EOS
+IP Address       Timestamp                   Data
+---------------  --------------------------  ---------------------------
+EOS
+
+  gossip.each do |address, timestamp, data|
+    t =  Time.at(timestamp.slice(0, 10).to_i, timestamp.slice(10..-1).to_i)
+    puts '%-15s  %19s.%06d  %s' % [address, t.strftime('%Y/%m/%d %H:%M:%S'), t.usec , data]
+  end
+end
+
+while cmd = Readline.readline('gossip> ', true)
+  begin
+    case cmd
+    when /\A\s*start\s*\Z/i
+      gossip.start
+    when /\A\s*stop\s*\Z/i
+      gossip.stop
+    when /\A\s*status\s*\Z/i
+      puts "running=#{gossip.running?}"
+    when /\A\s*list\s*\Z/i
+      list_nodes(gossip)
+    when /\A\s*data\s+(.+)\s*\Z/
+      gossip.data = $1
+    when /\A\s*add\s+(.+)\s*\Z/
+      gossip.add_node $1
+    when /\A\s*del\s+(.+)\s*\Z/
+      gossip.delete_node $1
+    when /\A\s*clear\s*\Z/
+      gossip.clear_dead_list
+    when /\A\s*log\s*\Z/
+      puts [:debug, :info, :warn, :error, :fatal][gossip.logger.level]
+    when /\A\s*log\s+(.+)\s*\Z/
+      gossip.logger.level = Logger.const_get($1.upcase)
+    when /\A\s*exit\s*\Z/
+      exit
+    else
+      puts "commands: #{commands.join '|'}"
+    end
+  rescue => e
+    $stderr.puts e
+  end
+end

data/lib/rgossip2/client.rb

@@ -0,0 +1,197 @@
+require 'socket'
+
+module RGossip2
+
+  #
+  # class Client
+  # ゴシッププロトコルのクライアント兼サーバ
+  # 
+  # +----------+          +--------+
+  # |  Client  |<>---+---+|  Node  |
+  # +----------+     |    +--------+
+  #                  |    +-----------------------+
+  #                  +---+|  @node_list:NodeList  |
+  #                  |    +-----------------------+
+  #                  |    +-----------------------+
+  #                  +---+|  @dead_list:NodeList  |
+  #                       +-----------------------+
+  #
+  class Client
+    include Enumerable
+    include ContextHelper
+
+    attr_reader :node_list
+    attr_reader :dead_list
+    attr_reader :self_node
+
+    attr_reader :context
+
+    def initialize(context, initial_nodes = [], address = nil, data = nil)
+      @context = context
+
+      # データがバッファサイズを超える場合はエラー
+      if data and data.length > @context.buffer_size
+        raise 'Data is too large'
+      end
+
+      # IPアドレスを取得。デフォルトはローカルホストアドレス
+      @address = name2addr(address || IPSocket.getaddress(Socket.gethostname))
+      info("Client is initialized: initial_nodes=#{initial_nodes.inspect}, address=#{@address}, data=#{data.inspect}")
+
+      # NodeListを生成
+      @node_list = create(NodeList)
+      @dead_list = create(NodeList)
+
+      # Nodeを生成
+      @self_node = create(Node, @node_list, @dead_list, @address, data, nil)
+      @self_node.update_timestamp
+      @node_list[@address] = @self_node
+
+      # 初期ノードを追加
+      initial_nodes.uniq.each do |i|
+        addr = name2addr(i)
+        @node_list[addr] = create(Node, @node_list, @dead_list, addr, nil, nil)
+      end
+
+      # Gossiper、Receiverを生成
+      @gossiper = create(Gossiper, @self_node, @node_list)
+      @receiver = create(Receiver, @self_node, @node_list, @dead_list)
+    end
+
+    def start
+      # 開始している場合はスキップ
+      return if @running
+
+      info("Client is started: address=#{@address}")
+
+      # NodoのTimerをスタート
+      @node_list.each do |node|
+        if node.address != @self_node.address
+          node.start_timer
+        end
+      end
+
+      @gossiper.start
+      @receiver.start
+    ensure
+      @running = true
+    end
+
+    def stop
+      # 停止している場合はスキップ
+      return unless @running
+
+      info("Client is stopped")
+
+      @gossiper.stop
+      @receiver.stop
+    ensure
+      @running = false
+    end
+
+    def join
+      @gossiper.join
+      @receiver.join
+    end
+
+    def running?
+      !!@running
+    end
+
+    def address
+      @self_node.address
+    end
+
+    def data
+      @node_list.synchronize {
+        @self_node.data
+      }
+    end
+
+    def data=(v)
+      @node_list.synchronize {
+        @self_node.data = v
+      }
+    end
+
+    # ノードの追加
+    def add_node(address)
+      address = name2addr(address)
+
+      @node_list.synchronize {
+        @dead_list.synchronize {
+          # すでに存在する場合はエラー
+          raise 'The node already exists' if @node_list[address]
+
+          node = create(Node, @node_list, @dead_list, address, nil, nil)
+          @node_list[address] = node
+
+          # デッドリストからは追加したノードを削除
+          @dead_list.delete(address)
+
+          node.start_timer if @running
+
+          callback(:add, address, nil, nil)
+        }
+      }
+    end
+
+    # ノードの削除
+    def delete_node(address)
+      address = name2addr(address)
+
+      # 自分自身は削除できない
+      raise 'Own node cannot be deleted' if @self_node.address == address
+
+      @node_list.synchronize {
+        @dead_list.synchronize {
+          # ノードリストから削除してTimerを止める
+          node = @node_list.delete(address)
+          node.stop_timer if node
+
+          # デッドリストからも削除
+          node = @dead_list.delete(address)
+          node.stop_timer if node
+
+          callback(:delete, address, nil, nil)
+        }
+      }
+    end
+
+    # デッドリストのクリーニング
+    def clear_dead_list
+      @dead_list.synchronize {
+        @dead_list.clear
+      }
+    end
+
+    # ノードを舐める
+    def each
+      @node_list.each do |node|
+        address = node.address.dup
+        timestamp = node.timestamp.dup
+
+        if data = node.data
+          data = data.dup
+        end
+
+        yield([address, timestamp, data])
+      end
+    end
+
+    def logger
+      @context.logger
+    end
+
+    private
+    def name2addr(name)
+      if /\A\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\Z/ =~ name
+        name
+      else
+        IPSocket.getaddress(name)
+      end
+    end
+
+  end # Client
+
+end # RGossip2

data/lib/rgossip2/context.rb

@@ -0,0 +1,82 @@
+require 'logger'
+require 'msgpack'
+require 'openssl'
+
+module RGossip2
+
+  #
+  # class Context
+  # ゴシッププロトコルのための各種変数格納クラス
+  # ほとんどのクラスから参照される
+  #
+  class Context
+    # ポート番号
+    attr_accessor :port
+
+    # バッファサイズと遊び
+    # 「buffer_size * allowance + digest_length」が 65515bytes 以下になるようにする
+    attr_accessor :buffer_size
+    attr_accessor :allowance
+
+    # ハッシュ関数のアルゴリズムと長さ
+    attr_accessor :digest_algorithm
+    attr_accessor :digest_length
+
+    # HMACの秘密鍵
+    attr_accessor :auth_key
+
+    # Nodeの寿命
+    attr_accessor :node_lifetime
+
+    # 送信インターバル
+    attr_accessor :gossip_interval
+
+    # 受信タイムアウト
+    attr_accessor :receive_timeout
+
+    # ロガー
+    attr_accessor :logger
+
+    # 各種ハンドラ
+    attr_accessor :callback_handler
+    attr_accessor :error_handler
+
+    def initialize(options = {})
+      unless @auth_key = options[:auth_key]
+        raise ':auth_key is required'
+      end
+
+      default_logger = Logger.new($stderr)
+      default_logger.level = Logger::INFO
+
+      defaults = {
+        :port             => 10870,
+        :buffer_size      => 512,
+        :allowance        => 3,
+        :node_lifetime    => 10,
+        :gossip_interval  => 0.1,
+        :receive_timeout  => 3,
+        :digest_algorithm => OpenSSL::Digest::SHA256,
+        :digest_length    => 32, # 256 / 8
+        :logger           => default_logger,
+        :callback_handler => nil,
+      }
+
+      defaults[:error_handler] = lambda do |e|
+        message = (["#{e.class}: #{e.message}"] + (e.backtrace || [])).join("\n\tfrom ")
+
+        if self.logger
+          self.logger.error(message)
+        else
+          $stderr.puts(message)
+        end
+      end
+
+      defaults.each do |k, v|
+        self.instance_variable_set("@#{k}", options.fetch(k, v))
+      end
+    end # initialize
+
+  end # Context
+
+end # RGossip2

data/lib/rgossip2/context_helper.rb

@@ -0,0 +1,55 @@
+module RGossip2
+
+  #
+  # module ContextHelper
+  # レシーバなしでコンテキストを操作するためのモジュール
+  #
+  module ContextHelper
+
+    private
+
+    def create(*args)
+      @context.create(*args)
+    end
+
+    # 他のクラスのインスタンスを生成して自分自身をセットする
+    def create(klass, *args)
+      klass.new(@context, *args)
+    end
+
+    # 各種ハンドラプロキシメソッド
+    def callback(action, address, timestamp, data)
+      if @context.callback_handler
+        @context.callback_handler.call([action, address, timestamp, data])
+      end
+    end
+
+    def handle_error(e)
+      if @context.error_handler
+        @context.error_handler.call(e)
+      else
+        raise e
+      end
+    end
+
+    # ノード情報群からハッシュ値とメッセージを生成する
+    def digest_and_message(nodes)
+      message = nodes.map {|i| i.to_a }.to_msgpack
+      hash = OpenSSL::HMAC::digest(@context.digest_algorithm.new, @context.auth_key, message)
+      [hash, message]
+    end
+
+    # ロギングプロキシメソッド
+    [:fatal, :error, :worn, :info, :debug].each do |name|
+      define_method(name) do |message|
+        if @context.logger
+          @context.logger.send(name, message)
+        else
+          $stderr.puts("#{name}: #{message}")
+        end
+      end
+    end
+
+  end # ContextHelper
+
+end # RGossip2

data/lib/rgossip2/gossipper.rb

@@ -0,0 +1,80 @@
+module RGossip2
+
+  #
+  # class Gossiper
+  # ゴシッププロトコルの送信クラス
+  #
+  # +------------+          +--------+
+  # |  Gossiper  |<>---+---+|  Node  |
+  # +------------+     |    +--------+
+  #                    |    +-----------------------+
+  #                    +---+|  @node_list:NodeList  |
+  #                         +-----------------------+
+  #
+  class Gossiper
+    include ContextHelper
+
+    def initialize(context, self_node, node_list)
+      @context = context
+      @self_node = self_node
+      @node_list = node_list
+    end
+
+    def start
+      info("Transmission was started: interval=#{@context.gossip_interval} port=#{@context.port}")
+
+      @running = true
+
+      # パケット送信スレッドを開始
+      @thread = Thread.start {
+        begin
+          sock = UDPSocket.open
+
+          while @running
+            begin
+              @node_list.synchronize { gossip(sock) }
+            rescue Exception => e
+              handle_error(e)
+            end
+
+            sleep(@context.gossip_interval)
+          end
+        ensure
+          sock.close
+        end
+      }
+    end # start
+
+    def stop
+      info("Transmission was stopped")
+
+      # フラグをfalseにしてスレッドを終了させる
+      @running = false
+    end
+
+    def join
+      @thread.join
+    end
+
+    private
+
+    # 送信処理の本体
+    def gossip(sock)
+      # 送信前にタイムスタンプを更新する
+      @self_node.update_timestamp
+
+      # ランダムで送信先を決定
+      dest = @node_list.choose_except(@self_node)
+      return unless dest # ないとは思うけど…
+
+      debug("Data is transmitted: address=#{dest.address}")
+
+      # チャンクに分けてデータを送信
+      @node_list.serialize.each do |chunk|
+        sock.send(chunk, 0, dest.address, @context.port)
+      end
+    end
+
+  end # Gossiper
+
+end # RGossip2

data/lib/rgossip2/node.rb

@@ -0,0 +1,94 @@
+require 'msgpack'
+
+module RGossip2
+
+  #
+  # class Node
+  # ノード情報を格納するクラス
+  # タイムアウトすると破棄される（＝デッドリストに追加される）
+  #
+  # +------------+          +--------+          +-----------------------+
+  # |  NodeList  |<>---+---+|  Node  |<>---+---+|  @node_list:NodeList  |
+  # +------------+     |    +--------+     |    +-----------------------+
+  # +------------+     |                   |    +-----------------------+
+  # |  Receiver  |<>---+                   +---+|  @dead_list:NodeList  |
+  # +------------+     |                   |    +-----------------------+
+  # +------------+     |                   |    +---------+
+  # |  Gossiper  |<>---+                   +---+|  Timer  |
+  # +------------+                              +---------+
+  #
+  class Node
+    include ContextHelper
+
+    attr_reader   :address
+    attr_accessor :timestamp
+    attr_accessor :data
+
+    # クラスの生成・初期化はContextクラスからのみ行う
+    # addressはユニークであること
+    def initialize(context, node_list, dead_list, address, data, timestamp)
+      @context = context
+
+      @node_list = node_list
+      @dead_list = dead_list
+      @address = address
+      @data = data
+      @timestamp = timestamp || ''
+
+      # node_lifetimeの時間内に更新されない場合
+      # TimerがNodeを破棄する
+      @timer = Timer.new(@context.node_lifetime) do
+        debug("Node timed out: address=#{@address}")
+
+        # ノードリストからNodeを削除
+        @node_list.synchronize {
+          @node_list.delete(@address)
+        }
+
+        # デッドリストにNodeを追加
+        @dead_list.synchronize {
+          @dead_list[@address] = self
+        }
+
+        # 破棄時の処理をコールバック
+        callback(:delete, @address, @timestamp, @data)
+      end
+    end
+
+    # Nodeのタイムスタンプを更新
+    def update_timestamp
+      now = Time.now
+      @timestamp = "#{now.tv_sec}#{now.tv_usec}"
+    end
+
+    # Arrayへの変換
+    def to_a
+      [@address, @timestamp, @data]
+    end
+    alias to_ary to_a
+
+    def start_timer
+      debug("Node timer is started: address=#{@address}")
+      @timer.start
+    end
+
+    def reset_timer
+      debug("Node timer is reset: address=#{@address}")
+      @timer.reset
+    end
+
+    def stop_timer
+      debug("Node timer is suspended: address=#{@address}")
+      @timer.stop
+    end
+
+    # ノード情報のシリアライズ
+    # ただし、シリアライズ後の長さを調べるだけで
+    # 実際のデータ送信には使われない
+    def serialize
+      self.to_a.to_msgpack
+    end
+
+  end # Node
+
+end # RGossip2

data/lib/rgossip2/node_list.rb

@@ -0,0 +1,94 @@
+require 'forwardable'
+require 'openssl'
+require 'thread'
+
+module RGossip2
+
+  #
+  # class NodeList
+  # Nodeのコンテナ
+  #
+  # +------------+           +------------+        +--------+
+  # |  Gossiper  |<>---+---+ |  NodeList  |<>-----+|  Node  |
+  # +------------+     |     +------------+        +--------+
+  # +------------+     |
+  # |  Receiver  |<>---+
+  # +------------+
+  #
+  class NodeList
+    include ContextHelper
+    extend Forwardable
+
+    def initialize(context)
+      @context = context
+      @nodes = {}
+      @mutex = Mutex.new
+    end
+
+    # Hashに委譲
+    def_delegators :@nodes, :[], :[]=, :delete
+
+    # Nodeの配列でイテレートする
+    def each
+      @nodes.values.each do |i|
+        yield(i)
+      end
+    end
+
+    # Mutex_mだとエラーになるので自前で定義
+    def synchronize
+      @mutex.synchronize do
+        yield
+      end
+    end
+
+    # 指定したNode以外のNodeをリストからランダムに選択する
+    def choose_except(node)
+      node_list = []
+
+      @nodes.each do |k, v|
+        node_list << v if k != node.address
+      end
+
+      node_list.empty? ? nil : node_list[rand(node_list.size)]
+    end
+
+    # ノード情報をいくつかの塊にごとにシリアライズする
+    def serialize
+      chunks = []
+      nodes = []
+      datasum = ''
+
+      # バッファサイズ
+      bufsiz = @context.buffer_size - @context.digest_length
+
+      # Nodeはランダムな順序に変換
+      @nodes.sort_by { rand }.each do |addr, node|
+        # 長さを知るためにシリアライズ
+        packed = node.serialize
+
+        # シリアライズしてバッファサイズ以下ならチャンクに追加
+        if (datasum + packed).length <= bufsiz
+          nodes << node
+          datasum << packed
+        else
+          chunks << digest_and_message(nodes).join
+          nodes.clear
+          datasum.replace('')
+
+          # バッファサイズを超える場合は次のチャンクに追加
+          redo
+        end
+      end
+
+      # 残りのNodeをチャンクに追加
+      unless nodes.empty?
+        chunks << digest_and_message(nodes).join
+      end
+
+      return chunks
+    end # serialize
+
+  end # Nodes
+
+end # RGossip2

data/lib/rgossip2/receiver.rb

@@ -0,0 +1,145 @@
+require 'msgpack'
+require 'openssl'
+
+module RGossip2
+
+  #
+  # class Receiver
+  # ゴシッププロトコルの受信クラス
+  #
+  # +------------+          +--------+
+  # |  Receiver  |<>---+---+|  Node  |
+  # +------------+     |    +--------+
+  #                    |    +-----------------------+
+  #                    +---+|  @node_list:NodeList  |
+  #                    |    +-----------------------+
+  #                    |    +-----------------------+
+  #                    +---+|  @dead_list:NodeList  |
+  #                         +-----------------------+
+  #
+  class Receiver
+    include ContextHelper
+
+    def initialize(context, self_node, node_list, dead_list)
+      @context = context
+      @self_node = self_node
+      @node_list = node_list
+      @dead_list = dead_list
+    end
+
+    def start
+      info("Reception is started: port=#{@context.port}")
+
+      @running = true
+
+      # パケット受信スレッドを開始
+      @thread = Thread.start {
+        begin
+          sock = UDPSocket.open
+          sock.bind(@self_node.address, @context.port)
+
+          while @running
+            receive(sock)
+          end
+        ensure
+          sock.close
+        end
+      }
+    end # start
+
+    def stop
+      info("Reception is stopped")
+
+      # フラグをfalseにしてスレッドを終了させる
+      @running = false
+    end
+
+    def join
+      @thread.join
+    end
+
+    private
+
+    # 受信処理の本体
+    def receive(sock)
+      return unless select([sock], [], [], @context.receive_timeout)
+      message, (afam, port, host, ip) = sock.recvfrom(@context.buffer_size * @context.allowance)
+
+      debug("Data was received: from=#{ip}")
+
+      recv_nodes = unpack_message(message)
+
+      if recv_nodes
+        @node_list.synchronize {
+          merge_lists(recv_nodes)
+        }
+      else
+        # データが取得できなかった場合は無効なデータとして処理
+        debug("Invalid data was received: from=#{ip}")
+      end
+    rescue Exception => e
+      handle_error(e)
+    end
+
+    # ハッシュ値をチェックしてメッセージをデシリアライズ
+    def unpack_message(message)
+      recv_hash = message.slice!(0, @context.digest_length)
+      recv_nodes = MessagePack.unpack(message)
+      hash, xxx = digest_and_message(recv_nodes)
+      (recv_hash == hash) ? recv_nodes : nil
+    rescue MessagePack::UnpackError => e
+      return nil
+    end
+
+    # ノードのマージ
+    def merge_lists(recv_nodes)
+      recv_nodes.each do |address, timestamp, data|
+        # 自分自身のアドレスならスキップ
+        next if address == @self_node.address
+
+        # ノードリストからアドレスの一致するNodeを探す
+        if (node = @node_list[address])
+          # ノードリストに見つかった場合
+
+          # 受信したNodeのタイムスタンプが新しければ
+          # 持っているNodeを更新
+          if timestamp > node.timestamp
+            debug("The node was updated: address=#{address} timestamp=#{timestamp}")
+
+            node.timestamp = timestamp
+            node.data = data
+            node.reset_timer
+
+            callback(:update, address, timestamp, data)
+          end
+        elsif (node = @dead_list.synchronize { @dead_list[address] })
+          # デッドリストに見つかった場合
+          @dead_list.synchronize {
+            # 受信したNodeのタイムスタンプが新しければ
+            # デッドリストのノードを復活させる
+            if timestamp > node.timestamp
+              debug("Node revived: address=#{address} timestamp=#{timestamp}")
+
+              @dead_list.delete(address)
+              @node_list[address] = node
+              node.start_timer
+
+              callback(:comeback, address, timestamp, data)
+            end
+          }
+        else
+          # リストにない場合はNodeを追加
+          debug("Node was added: address=#{address} timestamp=#{timestamp}")
+
+          node = create(Node, @node_list, @dead_list, address, data, timestamp)
+          @node_list[address] = node
+          node.start_timer
+
+          callback(:add, address, timestamp, data)
+        end
+      end
+    end # merge_lists
+
+  end # Receiver
+
+end # RGossip2

data/lib/rgossip2/timer.rb

@@ -0,0 +1,77 @@
+module RGossip2
+
+  #
+  # class Timer
+  # 一定時間でNodeを削除するためのクラス
+  # 唯一、Contextを参照しない
+  #
+  # +--------+        +---------+
+  # |  Node  |<>-----+|  Timer  |
+  # +--------+        +---------+
+  #
+  class Timer
+
+    def initialize(timeout, &block)
+      @timeout = timeout
+      @block = block
+    end
+
+    def start
+      # 既存のスレッドは破棄
+      @thread.kill if alive?
+      @start_time = Time.now
+
+      # スタート時点の「開始時刻」を引数に渡す
+      @thread = Thread.start(@start_time) {|start_time|
+        loop do
+          # タイムアウトするまでスリープ
+          sleep @timeout
+
+          if @start_time == start_time
+            # 開始時刻が変わっていない＝リセットされない場合
+            # 破棄の処理を呼び出してループを抜ける（＝スレッドの終了）
+            @block.call
+            break
+          elsif @start_time.nil?
+            # Timerがストップされていた場合
+            # 何もしないでループを抜ける（＝スレッドの終了）
+            break
+          else
+            # 開始時刻が更新された場合＝リセットされた場合
+            # start_timeを更新してループを継続（＝スレッドの継続）
+            start_time = @start_time
+          end
+        end # loop
+      } # Thread.start
+    end
+
+    # カウントダウンをリセットする
+    def reset
+      if alive?
+        @start_time = Time.now
+        @thread.run # 停止中のスレッドを強制起動してスリープ時間を更新
+      end
+    rescue ThreadError
+      # @thread.runで発生する可能性があるが無視
+    end
+
+    # カウントダウンを停止する
+    def stop
+      if alive?
+        @start_time = nil
+        @thread.run # 停止中のスレッドを強制起動して終了させる
+      end
+    rescue ThreadError
+      # @thread.runで発生する可能性があるが無視
+    end
+
+    private
+    # @thread: nil  => Timerが開始されていない
+    # @thread: dead => Timerはすでに終了
+    def alive?
+      @thread and @thread.alive?
+    end
+
+  end # Timer
+
+end # RGossip2

data/lib/rgossip2.rb

@@ -0,0 +1,24 @@
+require 'rgossip2/context'
+require 'rgossip2/context_helper'
+require 'rgossip2/client'
+require 'rgossip2/node'
+require 'rgossip2/node_list'
+require 'rgossip2/gossipper'
+require 'rgossip2/receiver'
+require 'rgossip2/timer'
+
+module RGossip2
+
+  # Clientの生成
+  # 直接、Client#newは実行しない
+  def client(options = {})
+    initial_nodes = options.delete(:initial_nodes) || []
+    address = options.delete(:address)
+    data = options.delete(:data)
+
+    context = Context.new(options)
+    Client.new(context, initial_nodes, address, data)
+  end
+  module_function :client
+
+end # RGossip2

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: rgossip2
+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-11-03 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: 
+- gossip
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- bin/gossip
+- lib/rgossip2.rb
+- lib/rgossip2/timer.rb
+- lib/rgossip2/gossipper.rb
+- lib/rgossip2/client.rb
+- lib/rgossip2/receiver.rb
+- lib/rgossip2/context.rb
+- lib/rgossip2/node.rb
+- lib/rgossip2/context_helper.rb
+- lib/rgossip2/node_list.rb
+homepage: https://bitbucket.org/winebarrel/rgossip2
+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: []
+