em-zmq-tp10 0.1.7

data/lib/em/protocols/zmq2/version.rb

@@ -0,0 +1,7 @@
+module EventMachine
+  module Protocols
+    module Zmq2
+      VERSION = '0.1.7'
+    end
+  end
+end

data/lib/em/protocols/zmq_tp10.rb

@@ -0,0 +1,2 @@
+require 'em/protocols/zmq2'
+EventMachine::Protocols::ZmqTP10 = EventMachine::Protocols::Zmq2

data/tests/helper.rb

@@ -0,0 +1,102 @@
+require 'ffi-rzmq'
+module Native
+  extend self
+  ZBIND_ADDR = 'tcp://127.0.0.1:7890'
+  ZCONNECT_ADDR = 'tcp://127.0.0.1:7891'
+
+  def native_context
+    @zctx = ZMQ::Context.new
+  end
+
+  def with_context
+    native_context
+    yield
+  ensure
+    close_context
+  end
+
+  def close_context
+    @zctx.terminate
+  end
+
+  def setup_pair(kind)
+    kind_n = ZMQ.const_get(kind)
+    @zbind = @zctx.socket(kind_n)
+    @zbind.identity = "BIND_#{kind}"
+    @zbind.bind(ZBIND_ADDR)
+    @zconnect = @zctx.socket(kind_n)
+    @zconnect.identity = "CONNECT_#{kind}"
+    @zconnect.connect(ZCONNECT_ADDR)
+    [@zbind, @zconnect]
+  end
+
+  def with_socket_pair(kind)
+    with_context do
+      begin
+        yield setup_pair(kind)
+      ensure
+        close_pair
+      end
+    end
+  end
+
+  def close_pair
+    @zbind.setsockopt(ZMQ::LINGER, 0)
+    @zconnect.setsockopt(ZMQ::LINGER, 0)
+    @zbind.close
+    @zconnect.close
+  end
+
+  def setup_socket(kind)
+    kind_n = ZMQ.const_get(kind)
+    @zbind = @zctx.socket(kind_n)
+    @zbind.identity = "BIND_#{kind}"
+    @zbind.bind(ZBIND_ADDR)
+    @zbind
+  end
+
+  def with_socket(kind)
+    with_context do
+      begin
+        yield setup_socket(kind)
+      ensure
+        close_socket
+      end
+    end
+  end
+
+  def close_socket
+    @zbind.setsockopt(ZMQ::LINGER, 0)
+    @zbind.close
+  end
+end
+
+module DeferredMixin
+  def initialize(opts={})
+    super(opts)
+    @connected = opts[:connected]
+    @finished = opts[:finished]
+  end
+
+  attr_writer :connected, :finished
+
+  def peer_free(peer_ident, connection)
+    super
+    if @connected && @free_peers.size == 2
+      @connected, connected = nil, @connected
+      connected.succeed
+    end
+  end
+end
+
+module IncomingMixin
+  attr :incoming_queue
+  def initialize(opts={})
+    super
+    @incoming_queue = []
+  end
+
+  def receive_message(message)
+    @incoming_queue << message
+  end
+end

data/tests/run_all.rb

@@ -0,0 +1,3 @@
+%w{req router dealer rep}.each do |what|
+  require File.expand_path("../test_#{what}.rb", __FILE__)
+end

data/tests/test_dealer.rb

@@ -0,0 +1,237 @@
+require 'eventmachine'
+require 'minitest/autorun'
+require File.expand_path('../helper.rb', __FILE__)
+
+require 'em/protocols/zmq2/dealer'
+
+describe 'Dealer' do
+
+  let(:connected) do
+    EM::DefaultDeferrable.new
+  end
+
+  describe EM::Protocols::Zmq2::PreDealer do
+    class MyPreDealer < EM::Protocols::Zmq2::PreDealer
+
+      attr :incoming_queue
+      def initialize(opts={})
+        super(opts)
+        @connected = opts[:connected]
+        @incoming_queue = []
+      end
+      def peer_free(peer_ident, connection)
+        super
+        @connected.succeed  if @free_peers.size == 2
+      end
+      def receive_message(message)
+        @incoming_queue << message
+      end
+    end
+
+    attr :dealer
+    before do
+      @dealer = MyPreDealer.new(identity: 'MyDealer', connected: connected)
+      @dealer.connect(Native::ZBIND_ADDR)
+      @dealer.bind(Native::ZCONNECT_ADDR)
+    end
+
+    let(:messages) do
+      64.times.map{|n| ['', 'hello', 'world', n.to_s]}
+    end
+
+    it "should be able to send message" do
+      results = []
+      Native.with_socket_pair('ROUTER') do |zbind, zconnect|
+        EM.run {
+          connected.callback {
+            messages.each{|message|
+              dealer.send_message(message).must_equal true
+            }
+            dealer.close do
+              EM.next_tick{ EM.stop }
+            end
+          }
+        }
+        result = []
+        while zbind.recv_strings(result, ZMQ::NOBLOCK) != -1
+          result.shift.must_equal 'MyDealer'
+          results << result
+          result = []
+        end
+        results.size.must_be :>, 0
+        results.size.must_be :<, messages.size
+        while zconnect.recv_strings(result, ZMQ::NOBLOCK) != -1
+          result.shift.must_equal 'MyDealer'
+          results << result
+          result = []
+        end
+      end
+      (messages - results).must_be_empty
+      (results - messages).must_be_empty
+    end
+
+    it "should be able to receive messages" do
+      Native.with_socket_pair('ROUTER') do |zbind, zconnect|
+        EM.run {
+          connected.callback {
+            messages[0...(messages.size/2)].each{|message|
+              zbind.send_strings ['MyDealer', *message]
+            }
+            messages[(messages.size/2)..-1].each{|message|
+              zconnect.send_strings ['MyDealer', *message]
+            }
+          }
+          cb = proc do
+            if dealer.incoming_queue.size < messages.size
+              EM.add_timer(0.5, cb)
+            else
+              EM.next_tick{ EM.stop }
+            end
+          end
+          cb.call
+        }
+      end
+      dealer.incoming_queue.size.must_equal messages.size
+      (dealer.incoming_queue - messages).must_be_empty
+      (messages - dealer.incoming_queue).must_be_empty
+    end
+  end
+
+  describe EM::Protocols::Zmq2::Dealer do
+    class MyDealer < EM::Protocols::Zmq2::Dealer
+      attr :incoming_queue, :canceled_messages
+      def initialize(opts={})
+        super(opts)
+        @connected = opts[:connected]
+        @incoming_queue = []
+        @canceled_messages = []
+      end
+      def peer_free(peer_ident, connection)
+        super
+        @connected.succeed  if @free_peers.size == 2
+      end
+      def receive_message(message)
+        @incoming_queue << message
+      end
+      def cancel_message(message)
+        @canceled_messages << message
+      end
+    end
+
+    attr :dealer
+    before do
+      @dealer = MyDealer.new(identity: 'MyDealer', connected: connected)
+      @dealer.connect(Native::ZBIND_ADDR)
+      @dealer.bind(Native::ZCONNECT_ADDR)
+    end
+
+    let(:messages) do
+      10000.times.map{|n| ['', 'hello', 'world', n.to_s]}
+    end
+
+    class RouteCollector
+      attr :res_a, :res_b
+      def initialize(till)
+        @till = till
+        @res_a, @res_b = [], []
+      end
+      def full?
+        @res_a.size + @res_b.size >= @till
+      end
+      def full_res
+        @res_a + @res_b
+      end
+      def set_sockets(zbind, zconnect)
+        @zbind = zbind
+        @zconnect = zconnect
+      end
+      def thread
+        Thread.new do
+          result = []
+          until full?
+            while @zbind.recv_strings(result, ZMQ::NOBLOCK) != -1
+              result.shift.must_equal 'MyDealer'
+              @res_a << result
+              result = []
+            end
+            while @zconnect.recv_strings(result, ZMQ::NOBLOCK) != -1
+              result.shift.must_equal 'MyDealer'
+              @res_b << result
+              result = []
+            end
+            sleep(0.01)
+          end
+        end
+      end
+    end
+
+    it "should be able to send a lot of messages" do
+      collector = RouteCollector.new(messages.size)
+      Native.with_socket_pair('ROUTER') do |zbind, zconnect|
+        collector.set_sockets zbind, zconnect
+        thrd = collector.thread
+        EM.run {
+          connected.callback {
+            messages.each{|message|
+              dealer.send_message(message)
+            }
+            dealer.close do
+              EM.next_tick{ EM.stop }
+            end
+          }
+        }
+        thrd.join
+      end
+      collector.full?.must_equal true
+      collector.res_a.size.must_be :>, 0
+      collector.res_a.size.must_be :<, messages.size
+      (messages - collector.full_res).must_be_empty
+      (collector.full_res - messages).must_be_empty
+    end
+
+    it "should be closed after writting" do
+      collector = RouteCollector.new(messages.size)
+      Native.with_socket_pair('ROUTER') do |zbind, zconnect|
+        collector.set_sockets zbind, zconnect
+        thrd = collector.thread
+        EM.run {
+          connected.callback {
+            messages.each{|message|
+              dealer.send_message(message)
+            }
+            dealer.close do
+              EM.next_tick{ EM.stop }
+            end
+          }
+        }
+        thrd.join
+      end
+      collector.full?.must_equal true
+      collector.res_a.size.must_be :>, 0
+      collector.res_a.size.must_be :<, messages.size
+      (messages - collector.full_res).must_be_empty
+      (collector.full_res - messages).must_be_empty
+    end
+
+    it "should not accept message on low hwm with strategy :drop_last" do
+      dealer.hwm = 1
+      dealer.hwm_strategy = :drop_last
+      EM.run {
+        dealer.send_message(['hi', 'ho1']).must_equal true
+        dealer.send_message(['hi', 'ho2']).wont_equal true
+        EM.stop
+      }
+    end
+
+    it "should cancel earlier message on low hwm with strategy :drop_first" do
+      dealer.hwm = 1
+      dealer.hwm_strategy = :drop_first
+      EM.run {
+        dealer.send_message(['hi', 'ho1']).must_equal true
+        dealer.send_message(['hi', 'ho2']).must_equal true
+        EM.stop
+      }
+      dealer.canceled_messages.must_equal [['hi', 'ho1']]
+    end
+  end
+end

data/tests/test_inproc.rb

@@ -0,0 +1,113 @@
+require 'eventmachine'
+require 'minitest/autorun'
+require File.expand_path('../helper.rb', __FILE__)
+
+require 'em/protocols/zmq2'
+
+describe 'InProc' do
+  let(:connected) do
+    EM::DefaultDeferrable.new
+  end
+
+  class IPDealer < EM::Protocols::Zmq2::Dealer
+    include DeferredMixin
+    include IncomingMixin
+    def peers
+      @peers
+    end
+  end
+
+  let(:messages) do
+    1000.times.map{|i| ['hi', i.to_s]}
+  end
+
+  let(:fan) do
+    IPDealer.new(connected: connected, identity: 'fan')
+  end
+
+  let(:sinks) do
+    2.times.map{|i| IPDealer.new(identity: "sink.#{i}") }
+  end
+
+  def run_test
+    EM.run {
+      connected.callback do
+        fan.peers['sink.0'].wont_be_nil
+        fan.peers['sink.1'].wont_be_nil
+        sinks.each{|sink| sink.peers['fan'].wont_be_nil}
+        messages.each{|message| fan.send_message(message)}
+        fan.close do
+          EM.next_tick{ EM.stop }
+        end
+      end
+    }
+    sinks.each do |sink|
+      sink.incoming_queue.size.must_be :>, 0
+      sink.incoming_queue.size.must_be :<, messages.size
+    end
+    incomings = sinks.map(&:incoming_queue).flatten(1)
+    (incomings - messages).must_be_empty
+    (messages - incomings).must_be_empty
+  end
+
+  it "should send messages to several connected socket" do
+    sinks.each{|sink| sink.connect 'inproc://fan'}
+    fan.bind 'inproc://fan'
+    run_test
+  end
+
+  it "should send messages to several binded sockets" do
+    sinks.each{|sink|
+      bind_point = "inproc://#{sink.identity}"
+      sink.bind bind_point
+      fan.connect bind_point
+    }
+    run_test
+  end
+
+  it "should send messages to inproc and tcp" do
+    sinks[0].bind 'tcp://127.0.0.1:9876'
+    fan.connect 'tcp://127.0.0.1:9876'
+    sinks[1].bind 'inproc://sink.1'
+    fan.connect 'inproc://sink.1'
+    run_test
+  end
+
+  if RUBY_PLATFORM !~ /window/
+    it "should send messages to inproc and tcp" do
+      sinks[0].bind 'ipc://falcon'
+      fan.connect 'ipc://falcon'
+      sinks[1].bind 'inproc://sink.1'
+      fan.connect 'inproc://sink.1'
+      run_test
+    end
+  end
+
+  class IPPub < EM::Protocols::Zmq2::Pub
+    include DeferredMixin
+    include IncomingMixin
+  end
+  class IPSub < EM::Protocols::Zmq2::Sub
+    include DeferredMixin
+    include IncomingMixin
+  end
+  it "should pub messages to inproc and tcp sub" do
+    pub = IPPub.new(identity: 'pub', connected: connected)
+    subs = 2.times.map{ sub = IPSub.new(subscribe: 'hi') }
+    subs[0].bind 'tcp://127.0.0.1:9876'
+    pub.connect 'tcp://127.0.0.1:9876'
+    subs[1].bind 'inproc://sink.1'
+    pub.connect 'inproc://sink.1'
+    EM.run {
+      connected.callback {
+        messages.each{|message| pub.send_message(message)}
+        pub.close do
+          EM.next_tick{ EM.stop }
+        end
+      }
+    }
+    subs.each {|sub|
+      sub.incoming_queue.must_equal messages
+    }
+  end
+end