em-zeromq 0.1.2 → 0.2.0.beta1

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,5 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in em-zeromq.gemspec
+gemspec
+

data/README.md

@@ -2,17 +2,17 @@
 
 Low level event machine support for ZeroMQ
 
-## Description: ##
-
-WARNING THIS IS ALPHA QUALITY AT THE MOMENT
+FOR NOW BUILD EVENTMACHINE FROM HEAD OR YOU WILL FIND A PAINFUL BUG
 
-A minimal test case passes, the basics of this are working.
-It needs work for sure, for instance, you cannot remove a socket yet
+## Description: ##
 
+This seems to work fine, no memory leaks, and it runs fast.
+It may not be perfect though, and the API is extremely minimal, just the bare minumum
+to make ZeroMQ work with EventMachine.
 
 ## Using: ##
 
-You must use either rubinius, jruby, or 1.9.x rubies. 1.8.7 unfixable issues.
+You must use either rubinius, jruby, or 1.9.x. 1.8.7 does not work with libzmq.
 
 If you use 1.9.x, be sure to install the ffi gem first.
 
@@ -23,10 +23,9 @@ Build+Install ZeroMQ 2.1 from HEAD ( https://github.com/zeromq/zeromq2 )
 
 Run the specs, see specs for examples
 
-Want to help out? Ask! Much work to be done here
+Want to help out? Ask!
 
 ## Example ##
-
     require 'rubygems'
     require 'em-zeromq'
         
@@ -40,25 +39,39 @@ Want to help out? Ask! Much work to be done here
         end
       end
     end
-    class EMTestPushHandler
-      def on_writable(socket)
-      end
-    end
+
     EM.run do
-      ZCTX  = ZMQ::Context.new 1
-      push = EM::ZeroMQ.create ZCTX, ZMQ::PUSH, :bind, 'tcp://127.0.0.1:2091', EMTestPushHandler.new
-      pull = EM::ZeroMQ.create ZCTX, ZMQ::PULL, :connect, 'tcp://127.0.0.1:2091', EMTestPullHandler.new
-          
-      EM::PeriodicTimer.new(1) {
-        push.socket.send_string "Hello World! #{Time.now}", ZMQ::NOBLOCK
-      }
+      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) 2009 FIXME (different 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

data/Rakefile

@@ -1,20 +1,7 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
 
-begin
-  require 'bones'
-rescue LoadError
-  abort '### Please install the "bones" gem ###'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |t|
 end
-
-#task :default => 'test:run'
-task 'gem:release' => 'test:run'
-  
-#depend_on 'ffi-rzmq', '0.7.0'
-#depend_on 'eventmachine'
-
-Bones {
-  name  'em-zeromq'
-  authors  'Andrew Cholakian'
-  email    'andrew@andrewvc.com'
-  url      'https://github.com/andrewvc/em-zeromq'
-}
-
+task :default => :spec

data/em-zeromq.gemspec

@@ -1,36 +1,29 @@
 # -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "em-zeromq/version"
 
 Gem::Specification.new do |s|
-  s.name = %q{em-zeromq}
-  s.version = "0.0.1"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Andrew Cholakian"]
-  s.date = %q{2011-02-01}
-  s.default_executable = %q{em-zeromq}
+  s.name        = "em-zeromq"
+  s.version     = EmZeromq::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Andrew Cholakian"]
+  s.email       = ["andrew@andrewvc.com"]
+  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.email = %q{andrew@andrewvc.com}
-  s.executables = ["em-zeromq"]
-  s.extra_rdoc_files = ["History.txt", "bin/em-zeromq", "lib/em-zeromq/.connection.rb.swp", "version.txt"]
-  s.files = [".Rakefile.swo", ".bnsignore", "History.txt", "README.md", "Rakefile", "bin/em-zeromq", "example/simple.rb", "lib/em-zeromq.rb", "lib/em-zeromq/.connection.rb.swp", "lib/em-zeromq/connection.rb", "lib/em-zeromq/zeromq.rb", "spec/.pub_sub_spec.rb.swp", "spec/pub_sub_spec.rb", "spec/push_pull_spec.rb", "spec/spec_helper.rb", "test/test_em-zeromq.rb", "version.txt"]
-  s.homepage = %q{https://github.com/andrewvc/em-zeromq}
   s.rdoc_options = ["--main", "README.md"]
-  s.require_paths = ["lib"]
-  s.rubyforge_project = %q{em-zeromq}
-  s.rubygems_version = %q{1.3.7}
-  s.summary = %q{Low level event machine support for ZeroMQ}
-  s.test_files = ["test/test_em-zeromq.rb"]
 
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
+  s.rubyforge_project = "em-zeromq"
+
+  s.add_dependency 'eventmachine', '>= 0.12.11'
+  s.add_dependency 'ffi-rzmq', '>= 0.7.2'
+  s.add_dependency 'ffi' if RUBY_PLATFORM != "java" && 
+                            defined?(RUBY_ENGINE) && RUBY_ENGINE != 'rbx'
+  s.add_development_dependency 'rspec', '>= 2.5.0'
 
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<bones>, [">= 3.5.4"])
-    else
-      s.add_dependency(%q<bones>, [">= 3.5.4"])
-    end
-  else
-    s.add_dependency(%q<bones>, [">= 3.5.4"])
-  end
+  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

@@ -1,4 +1,5 @@
 require 'rubygems'
+$LOAD_PATH << File.expand_path('../../lib', __FILE__)
 require 'em-zeromq'
     
 Thread.abort_on_exception = true
@@ -11,17 +12,30 @@ class EMTestPullHandler
     end
   end
 end
-class EMTestPushHandler
-  def on_writable(socket)
-  end
-end
+
 EM.run do
-  ZCTX  = ZMQ::Context.new 1
-  push = EM::ZeroMQ.create ZCTX, ZMQ::PUSH, :bind, 'tcp://127.0.0.1:2091', EMTestPushHandler.new
-  pull = EM::ZeroMQ.create ZCTX, ZMQ::PULL, :connect, 'tcp://127.0.0.1:2091', EMTestPullHandler.new
-      
-  EM::PeriodicTimer.new(1) {
-    push.socket.send_string "Hello World! #{Time.now}", ZMQ::NOBLOCK
-  }
+  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.rb

@@ -8,12 +8,6 @@ module EmZeromq
   PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
   # :startdoc:
 
-  # Returns the version string for the library.
-  #
-  def self.version
-    @version ||= File.read(path('version.txt')).strip
-  end
-
   # 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>.

data/lib/em-zeromq/connection.rb

@@ -10,13 +10,109 @@ module EventMachine
         @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)
+          true
+        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
+
+    private
+      # internal methods
       def readable?
         (@socket.getsockopt(ZMQ::EVENTS) & ZMQ::POLLIN) == ZMQ::POLLIN
       end
 
       def writable?
-        (@socket.getsockopt(ZMQ::EVENTS) & ZMQ::POLLOUT) == ZMQ::POLLOUT
+        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
 
       def notify_readable
@@ -40,46 +136,30 @@ module EventMachine
               end
             end
             
-            @handler.on_readable(@socket, msg_parts)
+            @handler.on_readable(self, msg_parts)
           else
             break
           end
         end
       end
       
-      def get_message
-        msg       = ZMQ::Message.new
-        msg_recvd = @socket.recv(msg, ZMQ::NOBLOCK)
-        msg_recvd ? msg : nil
-      end
-
       def notify_writable
-        if writable?
-          @handler.on_writable(@socket)
-        end
-      end
- 
-      # Stop triggering on_writable when socket is writable
-      def deregister_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
-      end
-       
-      # Make this socket available for reads
-      def register_readable
-        # Since ZMQ is event triggered I think this is necessary
-        if (@socket.getsockopt(ZMQ::EVENTS) & ZMQ::POLLIN) == ZMQ::POLLIN
-          notify_readable
+        
+        if @handler.respond_to?(:on_writable)
+          @handler.on_writable(self)
         end
-        self.notify_readable = true
       end
-     
-      # Trigger on_readable when socket is readable
-      def register_writable
-        # Since ZMQ is event triggered I think this is necessary
-        if (@socket.getsockopt(ZMQ::EVENTS) & ZMQ::POLLOUT) == ZMQ::POLLOUT
-          notify_writable
-        end
-        self.notify_writable = true
+      
+      def get_message
+        msg       = ZMQ::Message.new
+        msg_recvd = @socket.recv(msg, ZMQ::NOBLOCK)
+        msg_recvd ? msg : nil
       end
       
       # Detaches the socket from the EM loop,

data/lib/em-zeromq/context.rb

@@ -0,0 +1,73 @@
+#
+# different ways to create a socket:
+# ctx.bind(:xreq, 'tcp://127.0.0.1:6666')
+# ctx.bind('xreq', 'tcp://127.0.0.1:6666')
+# ctx.bind(ZMQ::XREQ, 'tcp://127.0.0.1:6666')
+#
+module EventMachine
+  module ZeroMQ
+    class Context
+      READABLES = [ ZMQ::SUB, ZMQ::PULL, ZMQ::XREQ, ZMQ::XREP, ZMQ::REP, ZMQ::REQ ]
+      WRITABLES = [ ZMQ::PUB, ZMQ::PUSH, ZMQ::XREQ, ZMQ::XREP, 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 bind(socket_type, address, handler = nil, opts = {})
+        create(socket_type, :bind, address, handler, opts)
+      end
+
+      def connect(socket_type, address, handler = nil, opts = {})
+        create(socket_type, :connect, address, handler, opts)
+      end
+      
+      def create(socket_type, bind_or_connect, address, handler, opts = {})
+        socket_type = find_type(socket_type)
+        socket = @context.socket(socket_type)
+        
+        ident = opts.delete(:identity)
+        if ident
+          socket.setsockopt(ZMQ::IDENTITY, ident)
+        end
+        
+        unless opts.empty?
+          raise "unknown keys: #{opts.keys.join(', ')}"
+        end
+
+        if bind_or_connect == :bind
+          socket.bind(address)
+        else
+          socket.connect(address)
+        end
+
+        conn = EM.watch(socket.getsockopt(ZMQ::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 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.2.0.beta1"
+end

data/spec/context_spec.rb

@@ -0,0 +1,25 @@
+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(:xreq, 'tcp://127.0.0.1:5555')
+      s2 = @ctx.bind('xreq', 'tcp://127.0.0.1:5556')
+      s3 = @ctx.bind(ZMQ::XREQ, 'tcp://127.0.0.1:5557')
+    
+      s1.instance_variable_get('@socket').name.should == 'XREQ'
+      EM::stop_event_loop
+    end
+  end
+end
+

data/spec/pub_sub_spec.rb

@@ -10,30 +10,11 @@ describe EventMachine::ZeroMQ do
       @received += messages
     end
   end
-  class EMTestPubHandler
-    def initialize(&block)
-      @on_writable_callback = block
-    end
-    def on_writable(socket)
-      @on_writable_callback.call(socket) if @on_writable_callback
-    end
-  end
-
-  def make_sub(addr, b_or_c, handler=EMTestSubHandler.new)
-    conn = EM::ZeroMQ.create SPEC_CTX, ZMQ::SUB, b_or_c, addr, handler
-    conn.socket.setsockopt(ZMQ::SUBSCRIBE,'')
-    conn.register_readable
-    conn
-  end
-  
-  def make_pub(addr, b_or_c, handler=EMTestPubHandler.new)
-    EM::ZeroMQ.create SPEC_CTX, ZMQ::PUB, b_or_c, addr, handler
-  end
 
   it "Should instantiate a connection given valid opts" do
     sub_conn = nil
-    run_reactor(2) do
-      sub_conn = make_sub(rand_addr, :bind, EMTestSubHandler.new)
+    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
@@ -45,8 +26,10 @@ describe EventMachine::ZeroMQ do
       
       run_reactor(0.5) do
         results[:sub_hndlr] = pull_hndlr = EMTestSubHandler.new
-        sub_conn  = make_sub rand_addr, :bind, pull_hndlr
-        pub_conn  = make_pub sub_conn.address, :connect
+        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
         
@@ -55,7 +38,7 @@ describe EventMachine::ZeroMQ do
       
       @results = results
     end
-
+  
     it "should run completely" do
       @results[:specs_ran].should be_true
     end

data/spec/push_pull_spec.rb

@@ -10,29 +10,11 @@ describe EventMachine::ZeroMQ do
       @received += messages
     end
   end
-  class EMTestPushHandler
-    def initialize(&block)
-      @on_writable_callback = block
-    end
-    def on_writable(socket)
-      @on_writable_callback.call(socket) if @on_writable_callback
-    end
-  end
-
-  def make_pull(addr, b_or_c, handler=EMTestPullHandler.new)
-    conn = EM::ZeroMQ.create SPEC_CTX, ZMQ::PULL, b_or_c, addr, handler
-    conn.register_readable
-    conn
-  end
-  
-  def make_push(addr, b_or_c, handler=EMTestPushHandler.new)
-    conn = EM::ZeroMQ.create SPEC_CTX, ZMQ::PUSH, b_or_c, addr, handler
-  end
 
   it "Should instantiate a connection given valid opts" do
     pull_conn = nil
     run_reactor do
-      pull_conn = make_pull(rand_addr, :bind, EMTestPullHandler.new)
+      pull_conn = SPEC_CTX.bind(ZMQ::PULL, rand_addr, EMTestPullHandler.new)
     end
     pull_conn.should be_a(EventMachine::ZeroMQ::Connection)
   end
@@ -44,8 +26,8 @@ describe EventMachine::ZeroMQ do
       
       run_reactor(0.5) do
         results[:pull_hndlr] = pull_hndlr = EMTestPullHandler.new
-        pull_conn  = make_pull rand_addr, :bind, pull_hndlr
-        push_conn  = make_push pull_conn.address, :connect
+        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
         

data/spec/spec_helper.rb

@@ -1,3 +1,4 @@
+require 'rspec'
 require 'set'
 Thread.abort_on_exception = true
 
@@ -36,7 +37,7 @@ def rand_addr(scheme='tcp')
   addr
 end
 
-SPEC_CTX = ZMQ::Context.new 1
+SPEC_CTX = EM::ZeroMQ::Context.new(1)
 def spec_ctx
   SPEC_CTX
 end

data/spec/xreq_xrep_spec.rb

@@ -10,6 +10,7 @@ describe EventMachine::ZeroMQ do
       @received += messages
     end
   end
+
   class EMTestXREPHandler
     attr_reader :received
     def initialize(&block)
@@ -21,29 +22,17 @@ describe EventMachine::ZeroMQ do
     end
     def on_readable(socket, messages)
       ident, delim, message = messages.map(&:copy_out_string)
+      ident.should == "req1"
       @received += [ident, delim, message].map {|s| ZMQ::Message.new(s)}
-      socket.send_string ident, ZMQ::SNDMORE
-      socket.send_string delim, ZMQ::SNDMORE
-      socket.send_string message
+      
+      socket.send_msg(ident, delim, "re:#{message}")
     end
   end
 
-  def make_xreq(addr, b_or_c, handler=EMTestXREQHandler.new)
-    conn = EM::ZeroMQ.create SPEC_CTX, ZMQ::XREQ, b_or_c, addr, handler
-    conn.register_readable
-    conn
-  end
-  
-  def make_xrep(addr, b_or_c, handler=EMTestXREPHandler.new)
-    conn = EM::ZeroMQ.create SPEC_CTX, ZMQ::XREP, b_or_c, addr, handler
-    conn.register_readable
-    conn
-  end
-
   it "Should instantiate a connection given valid opts" do
     xreq_conn = nil
     run_reactor(1) do
-      xreq_conn = make_xreq(rand_addr, :bind, EMTestXREQHandler.new)
+      xreq_conn = SPEC_CTX.bind(ZMQ::XREQ, rand_addr, EMTestXREQHandler.new)
     end
     xreq_conn.should be_a(EventMachine::ZeroMQ::Connection)
   end
@@ -51,18 +40,19 @@ describe EventMachine::ZeroMQ do
   describe "sending/receiving a single message via Xreq/Xrep" do
     before(:all) do
       results = {}
-      @test_message = test_message = "TMsg#{rand(999)}"
+      @test_message = test_message = "M#{rand(999)}"
       
-      run_reactor(1.5) do
+      run_reactor(0.5) do
         results[:xrep_hndlr] = xrep_hndlr = EMTestXREPHandler.new
         results[:xreq_hndlr] = xreq_hndlr = EMTestXREQHandler.new
-        xreq_conn  = make_xreq rand_addr,         :connect,    xreq_hndlr
-        xrep_conn  = make_xrep xreq_conn.address, :bind, xrep_hndlr
-         
-        xreq_conn.socket.send_string '', ZMQ::SNDMORE #delim
-        xreq_conn.socket.send_string test_message
+        xreq_conn = SPEC_CTX.connect(ZMQ::XREQ, rand_addr, xreq_hndlr, :identity => "req1")
+        xreq_conn.send_msg('', test_message)
+        
+        xrep_conn = SPEC_CTX.bind(ZMQ::XREP, xreq_conn.address, xrep_hndlr, :identity => "rep1")
          
-        EM::Timer.new(0.1) { results[:specs_ran] = true }
+        EM::Timer.new(0.1) do
+          results[:specs_ran] = true
+        end
       end
       
       @results = results
@@ -81,7 +71,7 @@ describe EventMachine::ZeroMQ do
     it "the xreq should be echoed its original message" do
       @results[:xreq_hndlr].received.should_not be_empty
       @results[:xreq_hndlr].received.last.should be_a(ZMQ::Message)
-      @results[:xreq_hndlr].received.last.copy_out_string.should == @test_message
+      @results[:xreq_hndlr].received.last.copy_out_string.should == "re:#{@test_message}"
     end
   end
 end

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: em-zeromq
 version: !ruby/object:Gem::Version 
-  hash: 31
-  prerelease: false
+  hash: -1848230051
+  prerelease: true
   segments: 
   - 0
-  - 1
   - 2
-  version: 0.1.2
+  - 0
+  - beta1
+  version: 0.2.0.beta1
 platform: ruby
 authors: 
 - Andrew Cholakian
@@ -15,59 +16,98 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-02 00:00:00 -08:00
+date: 2011-02-28 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: bones
+  name: eventmachine
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 57
+        segments: 
+        - 0
+        - 12
+        - 11
+        version: 0.12.11
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: ffi-rzmq
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 0
+        - 7
+        - 2
+        version: 0.7.2
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: ffi
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
         hash: 27
         segments: 
-        - 3
+        - 2
         - 5
-        - 4
-        version: 3.5.4
+        - 0
+        version: 2.5.0
   type: :development
-  version_requirements: *id001
+  version_requirements: *id004
 description: Low level event machine support for ZeroMQ
-email: andrew@andrewvc.com
-executables: 
-- em-zeromq
+email: 
+- andrew@andrewvc.com
+executables: []
+
 extensions: []
 
-extra_rdoc_files: 
-- History.txt
-- bin/em-zeromq
-- lib/em-zeromq/.connection.rb.swp
-- lib/em-zeromq/.zeromq.rb.swp
-- version.txt
+extra_rdoc_files: []
+
 files: 
-- .Rakefile.swo
 - .bnsignore
+- .gitignore
+- Gemfile
 - History.txt
 - README.md
 - Rakefile
-- bin/em-zeromq
 - em-zeromq.gemspec
 - example/simple.rb
 - lib/em-zeromq.rb
-- lib/em-zeromq/.connection.rb.swp
-- lib/em-zeromq/.zeromq.rb.swp
 - lib/em-zeromq/connection.rb
-- lib/em-zeromq/zeromq.rb
-- spec/.spec_helper.rb.swp
-- spec/.xreq_xrep_spec.rb.swp
+- 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/spec_helper.rb
 - spec/xreq_xrep_spec.rb
-- test/test_em-zeromq.rb
-- version.txt
 has_rdoc: true
 homepage: https://github.com/andrewvc/em-zeromq
 licenses: []
@@ -90,12 +130,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version 
-      hash: 3
+      hash: 25
       segments: 
-      - 0
-      version: "0"
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
 requirements: []
 
 rubyforge_project: em-zeromq
@@ -103,5 +145,5 @@ rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Low level event machine support for ZeroMQ
-test_files: 
-- test/test_em-zeromq.rb
+test_files: []
+

data/bin/em-zeromq

@@ -1,7 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.expand_path(
-    File.join(File.dirname(__FILE__), %w[.. lib em-zeromq]))
-
-# Put your code here
-

data/lib/em-zeromq/zeromq.rb

@@ -1,20 +0,0 @@
-module EventMachine
-  module ZeroMQ
-     def self.create(context, socket_type, bind_or_connect, address, handler)
-      socket = context.socket socket_type
-       
-      unless [:bind, :connect].include?(bind_or_connect)
-        raise ArgumentError, "Invalid Option '#{bind_or_connect}' try :bind or :connect"
-      end
-       
-      if bind_or_connect == :bind
-        socket.bind address
-      else
-        socket.connect address
-      end
-       
-      conn = EM.watch(socket.getsockopt(ZMQ::FD), EventMachine::ZeroMQ::Connection, socket, socket_type, address, handler)
-    end
-
-  end
-end

data/version.txt

@@ -1 +0,0 @@
-0.1.2