em-zeromq-mri 0.3.0.pre

data/.bnsignore

@@ -0,0 +1,18 @@
+# The list of files that should be ignored by Mr Bones.
+# Lines that start with '#' are comments.
+#
+# A .gitignore file can be used instead by setting it as the ignore
+# file in your Rakefile:
+#
+#   Bones {
+#     ignore_file  '.gitignore'
+#   }
+#
+# For a project with a C extension, the following would be a good set of
+# exclude patterns (uncomment them if you want to use them):
+# *.[oa]
+# *~
+announcement.txt
+coverage
+doc
+pkg

data/.gitignore

@@ -0,0 +1,14 @@
+*.swp
+*.swo
+*.swn
+
+*.rbc
+*~
+
+pkg
+
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.rvmrc

data/Gemfile

@@ -0,0 +1,8 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in em-zeromq.gemspec
+gemspec :name => "em-zeromq"
+gemspec :name => "em-zeromq-mri", :platform => :mri
+
+gem "ffi", :platforms => [:jruby, :mri]
+

data/History.txt

@@ -0,0 +1,4 @@
+== 1.0.0 / 2011-01-29
+
+* 1 major enhancement
+  * Birthday!

data/README.md

@@ -0,0 +1,117 @@
+# em-zeromq #
+
+## Description: ##
+
+EventMachine support for ZeroMQ
+
+## Usage: ##
+
+Tested and functional with Rubinius, jRuby, and MRI 1.9.2.
+
+MRI 1.8.7 is not supported because of it's poor thread support.
+
+The code ships as two alternative gems:
+
+ * em-zeromq     (based on the ffi-rzmq gem, available for all platforms)
+ * em-zeromq-mri (based on the zmq gem, which is only available for MRI rubies)
+
+The main reason for shipping two different gems is that rubygems version requirements
+don't support the specification dependent on the ruby being used to install the gem.
+
+If you are using MRI 1.9.2 and insist on using the ffi version, you must ensure that the
+ffi gem is installed for ffi-zeromq to work.
+
+Want to help out? Ask!
+
+## Requiring the code
+Either
+
+```ruby
+    require 'em-zeromq-mri'
+```
+or
+
+```ruby
+    require 'zmq'
+    require 'em-zeromq'
+```
+
+will work.
+
+If you prefer the ffi version:
+
+```ruby
+    require 'em-zeromq-ffi'
+```
+or
+
+```ruby
+    require 'ffi-rzmq'
+    require 'em-zeromq'
+```
+will do the trick.
+
+## Example ##
+```ruby
+    Thread.abort_on_exception = true
+
+    class EMTestPullHandler
+      attr_reader :received
+      def on_readable(socket, messages)
+        messages.each do |m|
+          puts m.copy_out_string
+        end
+      end
+    end
+
+    EM.run do
+      ctx = EM::ZeroMQ::Context.new(1)
+
+      # setup push sockets
+      push_socket1 = ctx.bind( ZMQ::PUSH, 'tcp://127.0.0.1:2091')
+      push_socket2 = ctx.bind( ZMQ::PUSH, 'ipc:///tmp/a')
+      push_socket3 = ctx.bind( ZMQ::PUSH, 'inproc://simple_test')
+
+      # setup one pull sockets listening to both push sockets
+      pull_socket = ctx.connect( ZMQ::PULL, 'tcp://127.0.0.1:2091', EMTestPullHandler.new)
+      pull_socket.connect('ipc:///tmp/a')
+      pull_socket.connect('inproc://simple_test')
+
+      n = 0
+
+      # push_socket.hwm = 40
+      # puts push_socket.hwm
+      # puts pull_socket.hwm
+
+      EM::PeriodicTimer.new(0.1) do
+        puts '.'
+        push_socket1.send_msg("t#{n += 1}_")
+        push_socket2.send_msg("i#{n += 1}_")
+        push_socket3.send_msg("p#{n += 1}_")
+      end
+    end
+```
+## License: ##
+
+(The MIT License)
+
+Copyright (c) 2011
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,25 @@
+require 'bundler'
+require 'rspec/core/rake_task'
+
+namespace :ffi do
+  Bundler::GemHelper.install_tasks :name => 'em-zeromq'
+  RSpec::Core::RakeTask.new(:spec) do |t|
+    t.rspec_opts = ['--color']
+    t.pattern = "spec/**/*_{spec,ffi}.rb"
+  end
+end
+
+namespace :mri do
+  Bundler::GemHelper.install_tasks :name => 'em-zeromq-mri'
+  RSpec::Core::RakeTask.new(:spec) do |t|
+    t.rspec_opts = ['--color']
+    t.pattern = "spec/**/*_{spec,mri}.rb"
+  end
+end
+
+[:spec, :build, :install, :release].each do |t|
+  desc "#{t} all versions"
+  task t => ["ffi:#{t}", "mri:#{t}"]
+end
+
+task :default => :spec

data/em-zeromq-mri.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "em-zeromq/version"
+
+Gem::Specification.new do |s|
+  s.name        = "em-zeromq-mri"
+  s.version     = EmZeromq::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Andrew Cholakian", "Stefan Kaes"]
+  s.email       = ["andrew@andrewvc.com", "skaes@railsexpress.de"]
+  s.homepage    = "https://github.com/andrewvc/em-zeromq"
+  s.summary     = %q{Low level event machine support for ZeroMQ}
+  s.description = %q{Low level event machine support for ZeroMQ}
+  s.rdoc_options = ["--main", "README.md"]
+
+  s.rubyforge_project = "em-zeromq"
+
+  s.add_dependency 'eventmachine', '>= 1.0.0.beta.4'
+  s.add_dependency 'zmq', '>= 2.1.4'
+
+  s.add_development_dependency 'rspec', '>= 2.5.0'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/em-zeromq.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "em-zeromq/version"
+
+Gem::Specification.new do |s|
+  s.name        = "em-zeromq"
+  s.version     = EmZeromq::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Andrew Cholakian", "Stefan Kaes"]
+  s.email       = ["andrew@andrewvc.com", "skaes@railsexpress.de"]
+  s.homepage    = "https://github.com/andrewvc/em-zeromq"
+  s.summary     = %q{Low level event machine support for ZeroMQ}
+  s.description = %q{Low level event machine support for ZeroMQ}
+  s.rdoc_options = ["--main", "README.md"]
+
+  s.rubyforge_project = "em-zeromq"
+
+  s.add_dependency 'eventmachine', '>= 1.0.0.beta.4'
+  s.add_dependency 'ffi-rzmq', '>= 0.8.2'
+
+  s.add_development_dependency 'rspec', '>= 2.5.0'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/example/simple.rb

@@ -0,0 +1,41 @@
+require 'rubygems'
+$LOAD_PATH << File.expand_path('../../lib', __FILE__)
+require 'em-zeromq'
+    
+Thread.abort_on_exception = true
+
+class EMTestPullHandler
+  attr_reader :received
+  def on_readable(socket, messages)
+    messages.each do |m|
+      puts m.copy_out_string
+    end
+  end
+end
+
+EM.run do
+  ctx = EM::ZeroMQ::Context.new(1)
+  
+  # setup push sockets
+  push_socket1 = ctx.bind( ZMQ::PUSH, 'tcp://127.0.0.1:2091')
+  push_socket2 = ctx.bind( ZMQ::PUSH, 'ipc:///tmp/a')
+  push_socket3 = ctx.bind( ZMQ::PUSH, 'inproc://simple_test')
+  
+  # setup one pull sockets listening to both push sockets
+  pull_socket = ctx.connect( ZMQ::PULL, 'tcp://127.0.0.1:2091', EMTestPullHandler.new)
+  pull_socket.connect('ipc:///tmp/a')
+  pull_socket.connect('inproc://simple_test')
+  
+  n = 0
+  
+  # push_socket.hwm = 40
+  # puts push_socket.hwm
+  # puts pull_socket.hwm
+  
+  EM::PeriodicTimer.new(0.1) do
+    puts '.'
+    push_socket1.send_msg("t#{n += 1}_")
+    push_socket2.send_msg("i#{n += 1}_")
+    push_socket3.send_msg("p#{n += 1}_")
+  end
+end

data/lib/em-zeromq/connection.rb

@@ -0,0 +1,179 @@
+module EventMachine
+  module ZeroMQ
+    class Connection < EventMachine::Connection
+      attr_accessor :on_readable, :on_writable, :handler
+      attr_reader   :socket, :socket_type, :address
+
+      def initialize(socket, socket_type, address, handler)
+        @socket      = socket
+        @socket_type = socket_type
+        @handler     = handler
+        @address     = address
+      end
+      
+      def self.map_sockopt(opt, name)
+        define_method(name){ @socket.getsockopt(opt) }
+        define_method("#{name}="){|val| @socket.setsockopt(opt, val) }
+      end
+      
+      map_sockopt(ZMQ::HWM, :hwm)
+      map_sockopt(ZMQ::SWAP, :swap)
+      map_sockopt(ZMQ::IDENTITY, :identity)
+      map_sockopt(ZMQ::AFFINITY, :affinity)
+      map_sockopt(ZMQ::SNDBUF, :sndbuf)
+      map_sockopt(ZMQ::RCVBUF, :rcvbuf)
+      
+      # pgm
+      map_sockopt(ZMQ::RATE, :rate)
+      map_sockopt(ZMQ::RECOVERY_IVL, :recovery_ivl)
+      map_sockopt(ZMQ::MCAST_LOOP, :mcast_loop)
+      
+      # User method
+      def bind(address)
+        @socket.bind(address)
+      end
+      
+      def connect(address)
+        @socket.connect(address)
+      end
+      
+      def subscribe(what = '')
+        raise "only valid on sub socket type (was #{@socket.name})" unless @socket.name == 'SUB'
+        @socket.setsockopt(ZMQ::SUBSCRIBE, what)
+      end
+      
+      def unsubscribe(what)
+        raise "only valid on sub socket type (was #{@socket.name})" unless @socket.name == 'SUB'
+        @socket.setsockopt(ZMQ::UNSUBSCRIBE, what)
+      end
+      
+      # send a non blocking message
+      # parts:  if only one argument is given a signle part message is sent
+      #         if more than one arguments is given a multipart message is sent
+      #
+      # return: true is message was queued, false otherwise
+      #
+      def send_msg(*parts)
+        parts = Array(parts[0]) if parts.size == 0
+        sent = true
+        
+        # multipart
+        parts[0...-1].each do |msg|
+          sent = @socket.send_string(msg, ZMQ::NOBLOCK | ZMQ::SNDMORE)
+          if sent == false
+            break
+          end
+        end
+        
+        if sent
+          # all the previous parts were queued, send
+          # the last one
+          @socket.send_string(parts[-1], ZMQ::NOBLOCK)
+        else
+          # error while sending the previous parts
+          # register the socket for writability
+          self.notify_writable = true
+          false
+        end
+      end
+      
+      def setsockopt(opt, value)
+        @socket.setsockopt(opt, value)
+      end
+      
+      # cleanup when ending loop
+      def unbind
+        detach_and_close
+      end
+      
+      # Make this socket available for reads
+      def register_readable
+        # Since ZMQ is event triggered I think this is necessary
+        if readable?
+          notify_readable
+        end
+        # Subscribe to EM read notifications
+        self.notify_readable = true
+      end
+
+      # Trigger on_readable when socket is readable
+      def register_writable
+        # Subscribe to EM write notifications
+        self.notify_writable = true
+      end
+
+      def notify_readable
+        # Not sure if this is actually necessary. I suppose it prevents us
+        # from having to to instantiate a ZMQ::Message unnecessarily.
+        # I'm leaving this is because its in the docs, but it could probably
+        # be taken out.
+        return unless readable?
+         
+        loop do
+          msg_parts = []
+          msg       = get_message
+          if msg
+            msg_parts << msg
+            while @socket.more_parts?
+              msg = get_message
+              if msg
+                msg_parts << msg
+              else
+                raise "Multi-part message missing a message!"
+              end
+            end
+            
+            @handler.on_readable(self, msg_parts)
+          else
+            break
+          end
+        end
+      end
+      
+      def notify_writable
+        return unless writable?
+        
+        # one a writable event is successfully received the socket
+        # should be accepting messages again so stop triggering
+        # write events
+        self.notify_writable = false
+        
+        if @handler.respond_to?(:on_writable)
+          @handler.on_writable(self)
+        end
+      end
+      def readable?
+        (@socket.getsockopt(ZMQ::EVENTS) & ZMQ::POLLIN) == ZMQ::POLLIN
+      end
+
+      def writable?
+        return true
+        # ZMQ::EVENTS has issues in ZMQ HEAD, we'll ignore this till they're fixed
+        # (@socket.getsockopt(ZMQ::EVENTS) & ZMQ::POLLOUT) == ZMQ::POLLOUT
+      end
+     
+    private
+    
+      # internal methods
+
+      if defined?(ZMQ::Message)
+        def get_message
+          msg       = ZMQ::Message.new
+          msg_recvd = @socket.recv(msg, ZMQ::NOBLOCK)
+          msg_recvd ? msg : nil
+        end
+      else
+        def get_message
+          @socket.recv(ZMQ::NOBLOCK)
+        end
+      end
+
+      # Detaches the socket from the EM loop,
+      # then closes the socket
+      def detach_and_close
+        detach
+        @socket.close
+      end
+    end
+  end
+end

data/lib/em-zeromq/context.rb

@@ -0,0 +1,86 @@
+#
+# different ways to create a socket:
+# ctx.bind(:router, 'tcp://127.0.0.1:6666')
+# ctx.bind('router', 'tcp://127.0.0.1:6666')
+# ctx.bind(ZMQ::ROUTER, 'tcp://127.0.0.1:6666')
+#
+module EventMachine
+  module ZeroMQ
+    class Context
+      READABLES = [ ZMQ::SUB, ZMQ::PULL, ZMQ::ROUTER, ZMQ::DEALER, ZMQ::REP, ZMQ::REQ ]
+      WRITABLES = [ ZMQ::PUB, ZMQ::PUSH, ZMQ::ROUTER, ZMQ::DEALER, ZMQ::REP, ZMQ::REQ ]
+      def initialize(threads_or_context)
+        if threads_or_context.is_a?(ZMQ::Context)
+          @context = threads_or_context
+        else
+          @context = ZMQ::Context.new(threads_or_context)
+        end
+      end
+
+      def socket(socket_type)
+        socket_type = find_type(socket_type)
+        @context.socket(socket_type)
+      end
+
+      def bind(socket_or_type, address, handler = nil, opts = {})
+        socket, type = create(socket_or_type, opts)
+        socket.bind(address)
+        watch(socket, type, address, handler, opts)
+      end
+
+      def connect(socket_or_type, address, handler = nil, opts = {})
+        socket, type = create(socket_or_type, opts)
+        socket.connect(address)
+        watch(socket, type, address, handler, opts)
+      end
+
+      def watch(socket, socket_type, address, handler, opts = {})
+        fd = socket.getsockopt(ZMQ::FD)
+        conn = EM.watch(fd, EventMachine::ZeroMQ::Connection, socket, socket_type, address, handler)
+
+        if READABLES.include?(socket_type)
+          conn.register_readable
+        end
+
+        if WRITABLES.include?(socket_type)
+          conn.register_writable
+        end
+
+        conn
+      end
+
+    private
+
+      def create(socket_or_type, opts = {})
+        if socket_or_type.is_a?(ZMQ::Socket)
+          socket = socket_or_type
+          type = socket_or_type.getsockopt(ZMQ::TYPE)
+        else
+          type = find_type(socket_or_type)
+          socket = @context.socket(type)
+        end
+
+        ident = opts.delete(:identity)
+        if ident
+          socket.setsockopt(ZMQ::IDENTITY, ident)
+        end
+
+        unless opts.empty?
+          raise "unknown keys: #{opts.keys.join(', ')}"
+        end
+
+        [socket, type]
+      end
+
+      def find_type(type)
+        if type.is_a?(Symbol) or type.is_a?(String)
+          ZMQ.const_get(type.to_s.upcase)
+        else
+          type
+        end
+      end
+
+    end
+
+  end
+end

data/lib/em-zeromq/version.rb

@@ -0,0 +1,4 @@
+# encoding: utf-8
+module EmZeromq
+  VERSION = "0.3.0.pre"
+end

data/lib/em-zeromq-c.rb

@@ -0,0 +1,2 @@
+require 'zmq'
+require 'em-zeromq'

data/lib/em-zeromq-ffi.rb

@@ -0,0 +1,2 @@
+require 'ffi-rzmq'
+require 'em-zeromq'

data/lib/em-zeromq.rb

@@ -0,0 +1,111 @@
+require 'eventmachine'
+
+# determine which zeromq library to load
+unless defined?(ZMQ)
+  begin
+    require 'ffi-rzmq'
+  rescue LoadError
+    require 'zmq'
+  end
+end
+
+unless defined?(ZMQ::Message)
+
+  module ZMQ
+    POLLIN = 1
+    POLLOUT = 2
+    POLLERR = 4
+
+    SocketTypeNameMap = {
+      PAIR=>"PAIR",
+      PUB=>"PUB",
+      SUB=>"SUB",
+      REQ=>"REQ",
+      REP=>"REP",
+      DEALER=>"DEALER",
+      ROUTER=>"ROUTER",
+      PULL=>"PULL",
+      PUSH=>"PUSH",
+      #XPUB=>"XPUB",
+      #XSUB=>"XSUB"
+    }
+
+    class Socket
+      def name
+        @name ||= SocketTypeNameMap[getsockopt(TYPE)]
+      end
+      alias send_string send
+
+      def more_parts?
+        getsockopt(RCVMORE)
+      end
+    end
+
+  end
+
+  class String
+    def copy_out_string
+      self
+    end
+  end
+end
+
+
+module EmZeromq
+
+  # :stopdoc:
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  # :startdoc:
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args, &block )
+    rv =  args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+    if block
+      begin
+        $LOAD_PATH.unshift LIBPATH
+        rv = block.call
+      ensure
+        $LOAD_PATH.shift
+      end
+    end
+    return rv
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  #
+  def self.path( *args, &block )
+    rv = args.empty? ? PATH : ::File.join(PATH, args.flatten)
+    if block
+      begin
+        $LOAD_PATH.unshift PATH
+        rv = block.call
+      ensure
+        $LOAD_PATH.shift
+      end
+    end
+    return rv
+  end
+
+  # Utility method used to require all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  #
+  def self.require_all_libs_relative_to( fname, dir = nil )
+    dir ||= ::File.basename(fname, '.*')
+    search_me = ::File.expand_path(
+        ::File.join(::File.dirname(fname), dir, '**', '*.rb'))
+
+    Dir.glob(search_me).sort.each {|rb| require rb}
+  end
+
+end  # module EmZeromq
+
+EmZeromq.require_all_libs_relative_to(__FILE__)
+

data/spec/context_spec.rb

@@ -0,0 +1,27 @@
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe 'Context' do
+  before do
+    @ctx = EM::ZeroMQ::Context.new(1)
+  end
+  
+  it 'can be created with a context' do
+    zmq_ctx = ZMQ::Context.new(1)
+    ctx = EM::ZeroMQ::Context.new( zmq_ctx )
+    ctx.instance_variable_get('@context').should == zmq_ctx
+  end
+  
+  it 'can create socket' do
+    EM::run do
+      s1 = @ctx.bind(:router, 'tcp://127.0.0.1:5555')
+      s2 = @ctx.bind('router', 'tcp://127.0.0.1:5556')
+      s3 = @ctx.bind(ZMQ::ROUTER, 'tcp://127.0.0.1:5557')
+    
+      expected_socket_type_name = ZMQ::SocketTypeNameMap[ZMQ::ROUTER]
+
+      s1.instance_variable_get('@socket').name.should == expected_socket_type_name
+      EM::stop_event_loop
+    end
+  end
+end
+

data/spec/pub_sub_spec.rb

@@ -0,0 +1,60 @@
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe EventMachine::ZeroMQ do
+  class EMTestSubHandler
+    attr_reader :received
+    def initialize
+      @received = []
+    end
+    def on_readable(socket, messages)
+      @received += messages
+    end
+  end
+
+  it "Should instantiate a connection given valid opts" do
+    sub_conn = nil
+    run_reactor(1) do
+      sub_conn = SPEC_CTX.bind(ZMQ::PUB, rand_addr, EMTestSubHandler.new)
+    end
+    sub_conn.should be_a(EventMachine::ZeroMQ::Connection)
+  end
+
+  describe "sending/receiving a single message via PUB/SUB" do
+    before(:all) do
+      results = {}
+      @test_message = test_message = "TMsg#{rand(999)}"
+      
+      run_reactor(0.5) do
+        results[:sub_hndlr] = pull_hndlr = EMTestSubHandler.new
+        sub_conn  = SPEC_CTX.bind(ZMQ::SUB, rand_addr, pull_hndlr)
+        sub_conn.subscribe('')
+        
+        pub_conn  = SPEC_CTX.connect(ZMQ::PUB, sub_conn.address, EMTestSubHandler.new)
+        
+        pub_conn.socket.send_string test_message, ZMQ::NOBLOCK
+        
+        EM::Timer.new(0.1) { results[:specs_ran] = true }
+      end
+      
+      @results = results
+    end
+  
+    it "should run completely" do
+      @results[:specs_ran].should be_true
+    end
+    
+    it "should receive one message" do
+      @results[:sub_hndlr].received.length.should == 1
+    end
+
+    if defined?(ZMQ::Message)
+      it "should receive the message as a ZMQ::Message" do
+        @results[:sub_hndlr].received.first.should be_a(ZMQ::Message)
+      end
+    end
+    
+    it "should receive the message intact" do
+      @results[:sub_hndlr].received.first.copy_out_string.should == @test_message
+    end
+  end
+end

data/spec/push_pull_spec.rb

@@ -0,0 +1,50 @@
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe EventMachine::ZeroMQ do
+  class EMTestPullHandler
+    attr_reader :received
+    def initialize
+      @received = []
+    end
+    def on_readable(socket, messages)
+      @received += messages
+    end
+  end
+
+  it "Should instantiate a connection given valid opts" do
+    pull_conn = nil
+    run_reactor do
+      pull_conn = SPEC_CTX.bind(ZMQ::PULL, rand_addr, EMTestPullHandler.new)
+    end
+    pull_conn.should be_a(EventMachine::ZeroMQ::Connection)
+  end
+
+  describe "sending/receiving a single message via PUB/SUB" do
+    before(:all) do
+      results = {}
+      @test_message = test_message = "TMsg#{rand(999)}"
+      
+      run_reactor(0.5) do
+        results[:pull_hndlr] = pull_hndlr = EMTestPullHandler.new
+        pull_conn = SPEC_CTX.bind(ZMQ::PULL, rand_addr, pull_hndlr)
+        push_conn  = SPEC_CTX.connect(ZMQ::PUSH, pull_conn.address)
+        
+        push_conn.socket.send_string test_message, ZMQ::NOBLOCK
+        
+        EM::Timer.new(0.1) { results[:specs_ran] = true }
+      end
+      
+      @results = results
+    end
+
+    it "should run completely" do
+      @results[:specs_ran].should be_true
+    end
+    
+    it "should receive the message intact" do
+      @results[:pull_hndlr].received.should_not be_empty
+      @results[:pull_hndlr].received.first.should be_a(ZMQ::Message) if defined?(ZMQ::Message)
+      @results[:pull_hndlr].received.first.copy_out_string.should == @test_message
+    end
+  end
+end

data/spec/router_dealer_spec.rb

@@ -0,0 +1,80 @@
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe EventMachine::ZeroMQ do
+  class EMTestRouterHandler
+    attr_reader :received
+    def initialize
+      @received = []
+    end
+    def on_writable(socket)
+    end
+    def on_readable(socket, messages)
+      @received += messages
+    end
+  end
+
+  class EMTestDealerHandler
+    attr_reader :received
+    def initialize(&block)
+      @received = []
+      @on_writable_callback = block
+    end
+    def on_writable(socket)
+      @on_writable_callback.call(socket) if @on_writable_callback
+    end
+    def on_readable(socket, messages)
+      ident, delim, message = messages.map(&:copy_out_string)
+      ident.should == "dealer1"
+      @received += [ident, delim, message].map {|s| ZMQ::Message.new(s)}
+      
+      socket.send_msg(ident, delim, "re:#{message}")
+    end
+  end
+
+  it "Should instantiate a connection given valid opts for Router/Dealer" do
+    router_conn = nil
+    run_reactor(1) do
+      router_conn = SPEC_CTX.bind(ZMQ::ROUTER, rand_addr, EMTestRouterHandler.new)
+    end
+    router_conn.should be_a(EventMachine::ZeroMQ::Connection)
+  end
+
+  describe "sending/receiving a single message via Router/Dealer" do
+    before(:all) do
+      results = {}
+      @test_message = test_message = "M#{rand(999)}"
+      
+      run_reactor(0.5) do
+        results[:dealer_hndlr] = dealer_hndlr = EMTestDealerHandler.new
+        results[:router_hndlr] = router_hndlr = EMTestRouterHandler.new
+
+        addr = rand_addr
+        dealer_conn = SPEC_CTX.bind(ZMQ::DEALER, addr, dealer_hndlr, :identity => "dealer1")
+        router_conn = SPEC_CTX.connect(ZMQ::ROUTER, addr, router_hndlr, :identity => "router1")
+        router_conn.send_msg('x', test_message)
+         
+        EM::Timer.new(0.1) do
+          results[:specs_ran] = true
+        end
+      end
+      
+      @results = results
+    end
+
+    it "should run completely" do
+      @results[:specs_ran].should be_true
+    end
+    
+    xit "should receive the message intact on the dealer" do
+      @results[:dealer_hndlr].received.should_not be_empty
+      @results[:dealer_hndlr].received.last.should be_a(ZMQ::Message) if defined?(ZMQ::Message)
+      @results[:dealer_hndlr].received.last.copy_out_string.should == @test_message
+    end
+
+    xit "the router should be echoed its original message" do
+      @results[:router_hndlr].received.should_not be_empty
+      @results[:router_hndlr].received.last.should be_a(ZMQ::Message) if defined?(ZMQ::Message)
+      @results[:router_hndlr].received.last.copy_out_string.should == "re:#{@test_message}"
+    end
+  end
+end

data/spec/setup_ffi.rb

@@ -0,0 +1 @@
+# when passed along as part of the tests to run, the spec helper will load ffi-rzmq instead of zmq

data/spec/setup_mri.rb

@@ -0,0 +1 @@
+# when passed along as part of the tests to run, the spec helper will load zmq instead of ffi-rzmq

data/spec/spec_helper.rb

@@ -0,0 +1,51 @@
+require 'rspec'
+require 'set'
+Thread.abort_on_exception = true
+
+if ARGV.detect{|a| a =~ /setup_mri.rb$/}
+  puts "loading zmq"
+  require "zmq"
+elsif ARGV.detect{|a| a =~ /setup_ffi.rb$/}
+  puts "loading ffi-rzmq"
+  require "ffi-rzmq"
+end
+
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. lib em-zeromq]))
+
+def run_reactor(time=0.2,&block)
+  Thread.new do
+    EM.run do
+      yield
+    end
+  end
+  sleep time
+  EM.stop rescue nil
+  sleep 0.1
+end
+
+USED_RAND_ADDRS = Set.new
+def rand_addr(scheme='tcp')
+  addr = nil
+  loop do 
+    case scheme
+    when 'tcp'
+      addr = "tcp://127.0.0.1:#{rand(10_000) + 20_000}"
+    when 'inproc'
+      addr = "inproc://testinp-#{rand(10_000) + 20_000}"
+    end
+    
+    if USED_RAND_ADDRS.include? addr
+      next
+    else
+      USED_RAND_ADDRS << addr
+      break
+    end
+  end
+  addr
+end
+
+SPEC_CTX = EM::ZeroMQ::Context.new(1)
+def spec_ctx
+  SPEC_CTX
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: em-zeromq-mri
+version: !ruby/object:Gem::Version
+  version: 0.3.0.pre
+  prerelease: 6
+platform: ruby
+authors:
+- Andrew Cholakian
+- Stefan Kaes
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-14 00:00:00.000000000 +02:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: &2151446960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.beta.4
+  type: :runtime
+  prerelease: false
+  version_requirements: *2151446960
+- !ruby/object:Gem::Dependency
+  name: zmq
+  requirement: &2151445760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.1.4
+  type: :runtime
+  prerelease: false
+  version_requirements: *2151445760
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2151444700 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.5.0
+  type: :development
+  prerelease: false
+  version_requirements: *2151444700
+description: Low level event machine support for ZeroMQ
+email:
+- andrew@andrewvc.com
+- skaes@railsexpress.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .bnsignore
+- .gitignore
+- Gemfile
+- History.txt
+- README.md
+- Rakefile
+- em-zeromq-mri.gemspec
+- em-zeromq.gemspec
+- example/simple.rb
+- lib/em-zeromq-c.rb
+- lib/em-zeromq-ffi.rb
+- lib/em-zeromq.rb
+- lib/em-zeromq/connection.rb
+- lib/em-zeromq/context.rb
+- lib/em-zeromq/version.rb
+- spec/context_spec.rb
+- spec/pub_sub_spec.rb
+- spec/push_pull_spec.rb
+- spec/router_dealer_spec.rb
+- spec/setup_ffi.rb
+- spec/setup_mri.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: https://github.com/andrewvc/em-zeromq
+licenses: []
+post_install_message: 
+rdoc_options:
+- --main
+- README.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: em-zeromq
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Low level event machine support for ZeroMQ
+test_files:
+- spec/context_spec.rb
+- spec/pub_sub_spec.rb
+- spec/push_pull_spec.rb
+- spec/router_dealer_spec.rb
+- spec/setup_ffi.rb
+- spec/setup_mri.rb
+- spec/spec_helper.rb