em-zeromq 0.1.1 → 0.1.2

data/lib/em-zeromq/connection.rb

@@ -1,4 +1,3 @@
-
 module EventMachine
   module ZeroMQ
     class Connection < EventMachine::Connection
@@ -12,14 +11,24 @@ module EventMachine
         @address     = address
       end
 
+      def readable?
+        (@socket.getsockopt(ZMQ::EVENTS) & ZMQ::POLLIN) == ZMQ::POLLIN
+      end
+
+      def writable?
+        (@socket.getsockopt(ZMQ::EVENTS) & ZMQ::POLLOUT) == ZMQ::POLLOUT
+      end
+
       def notify_readable
-        return unless read_capable?
-        #return unless (@socket.getsockopt(ZMQ::EVENTS) & ZMQ::POLLOUT) == ZMQ::POLLOUT
+        # 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?
          
-        msg_parts = []
-
         loop do
-          msg = get_message
+          msg_parts = []
+          msg       = get_message
           if msg
             msg_parts << msg
             while @socket.more_parts?
@@ -44,29 +53,40 @@ module EventMachine
         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
         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
+        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
       end
       
-      def notify_writable
-        @handler.on_writable(@socket)
-      end
-      
-      private
-      
-      def read_capable?
-        @read_capable  ||= EM::ZeroMQ::READABLE_TYPES.include? @socket_type
-      end
-
-      def write_capable?
-        @write_capable ||= EM::ZeroMQ::WRITABLE_TYPES.include? @socket_type
+      # Detaches the socket from the EM loop,
+      # then closes the socket
+      def detach_and_close
+        detach
+        @socket.close
       end
     end
   end

data/lib/em-zeromq/zeromq.rb

@@ -1,8 +1,5 @@
 module EventMachine
   module ZeroMQ
-    READABLE_TYPES = [ZMQ::SUB, ZMQ::PULL, ZMQ::REQ, ZMQ::REP, ZMQ::XREQ, ZMQ::XREP, ZMQ::PAIR]
-    WRITABLE_TYPES = [ZMQ::PUB, ZMQ::PUSH, ZMQ::REQ, ZMQ::REP, ZMQ::XREQ, ZMQ::XREP, ZMQ::PAIR]
-
      def self.create(context, socket_type, bind_or_connect, address, handler)
       socket = context.socket socket_type
        
@@ -17,13 +14,6 @@ module EventMachine
       end
        
       conn = EM.watch(socket.getsockopt(ZMQ::FD), EventMachine::ZeroMQ::Connection, socket, socket_type, address, handler)
-      conn.notify_readable = true if EM::ZeroMQ::READABLE_TYPES.include? socket_type
-      
-      #Given the nature of ZMQ this isn't that useful, and will generally
-      #cause perf problems as it repeatedly triggers. If people really want to
-      #use it, they should do so explicitly
-      conn.notify_writable = false
-      conn
     end
 
   end

data/spec/pub_sub_spec.rb

@@ -22,6 +22,7 @@ describe EventMachine::ZeroMQ do
   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
   

data/spec/push_pull_spec.rb

@@ -20,11 +20,13 @@ describe EventMachine::ZeroMQ do
   end
 
   def make_pull(addr, b_or_c, handler=EMTestPullHandler.new)
-    EM::ZeroMQ.create SPEC_CTX, ZMQ::PULL, b_or_c, addr, handler
+    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)
-    EM::ZeroMQ.create SPEC_CTX, ZMQ::PUSH, b_or_c, addr, handler
+    conn = EM::ZeroMQ.create SPEC_CTX, ZMQ::PUSH, b_or_c, addr, handler
   end
 
   it "Should instantiate a connection given valid opts" do
@@ -57,15 +59,9 @@ describe EventMachine::ZeroMQ do
       @results[:specs_ran].should be_true
     end
     
-    it "should receive one message" do
-      @results[:pull_hndlr].received.length.should == 1
-    end
-    
-    it "should receive the message as a ZMQ::Message" do
-      @results[:pull_hndlr].received.first.should be_a(ZMQ::Message)
-    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)
       @results[:pull_hndlr].received.first.copy_out_string.should == @test_message
     end
   end

data/spec/xreq_xrep_spec.rb

@@ -0,0 +1,87 @@
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe EventMachine::ZeroMQ do
+  class EMTestXREQHandler
+    attr_reader :received
+    def initialize
+      @received = []
+    end
+    def on_readable(socket, messages)
+      @received += messages
+    end
+  end
+  class EMTestXREPHandler
+    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)
+      @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
+    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)
+    end
+    xreq_conn.should be_a(EventMachine::ZeroMQ::Connection)
+  end
+
+  describe "sending/receiving a single message via Xreq/Xrep" do
+    before(:all) do
+      results = {}
+      @test_message = test_message = "TMsg#{rand(999)}"
+      
+      run_reactor(1.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
+         
+        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 on the xrep" do
+      @results[:xrep_hndlr].received.should_not be_empty
+      @results[:xrep_hndlr].received.last.should be_a(ZMQ::Message)
+      @results[:xrep_hndlr].received.last.copy_out_string.should == @test_message
+    end
+
+    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
+    end
+  end
+end

data/version.txt

@@ -1 +1 @@
-0.1.1
+0.1.2

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: em-zeromq
 version: !ruby/object:Gem::Version 
+  hash: 31
   prerelease: false
   segments: 
   - 0
   - 1
-  - 1
-  version: 0.1.1
+  - 2
+  version: 0.1.2
 platform: ruby
 authors: 
 - Andrew Cholakian
@@ -14,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-01 00:00:00 -08:00
+date: 2011-02-02 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -25,11 +26,12 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 27
         segments: 
         - 3
-        - 6
-        - 2
-        version: 3.6.2
+        - 5
+        - 4
+        version: 3.5.4
   type: :development
   version_requirements: *id001
 description: Low level event machine support for ZeroMQ
@@ -41,10 +43,12 @@ extensions: []
 extra_rdoc_files: 
 - History.txt
 - bin/em-zeromq
+- lib/em-zeromq/.connection.rb.swp
+- lib/em-zeromq/.zeromq.rb.swp
+- version.txt
 files: 
 - .Rakefile.swo
 - .bnsignore
-- .gitignore
 - History.txt
 - README.md
 - Rakefile
@@ -52,11 +56,16 @@ files:
 - 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
 - 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
@@ -74,6 +83,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
@@ -82,6 +92,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"

data/.gitignore

@@ -1,8 +0,0 @@
-*.swp
-*.swo
-*.swn
-
-*.rbc
-*~
-
-pkg