ffi-rzmq 0.9.6 → 0.9.7

data/lib/ffi-rzmq/poll_item.rb

@@ -0,0 +1,56 @@
+require 'forwardable'
+require 'io_extensions'
+
+module ZMQ
+  class PollItem
+    extend Forwardable
+
+    def_delegators :@poll_item, :pointer, :readable?, :writable?
+    attr_accessor :pollable, :poll_item
+
+    def initialize(zmq_poll_item = nil)
+      @poll_item = zmq_poll_item || LibZMQ::PollItem.new
+    end
+
+    def self.from_pointer(pointer)
+      self.new(LibZMQ::PollItem.new(pointer))
+    end
+
+    def self.from_pollable(pollable)
+      item = self.new
+      item.pollable = pollable
+      case
+      when pollable.respond_to?(:socket)
+        item.socket = pollable.socket
+      when pollable.respond_to?(:posix_fileno)
+        item.fd = pollable.posix_fileno
+      when pollable.respond_to?(:io)
+        item.fd = pollable.io.posix_fileno
+      end
+      item
+    end
+
+    def closed?
+      case
+      when pollable.respond_to?(:closed?)
+        pollable.closed?
+      when pollable.respond_to?(:socket)
+        pollable.socket.nil?
+      when pollable.respond_to?(:io)
+        pollable.io.closed?
+      end
+    end
+
+    def socket=(arg); @poll_item[:socket] = arg; end
+
+    def socket; @poll_item[:socket]; end
+
+    def fd=(arg); @poll_item[:fd] = arg; end
+
+    def fd; @poll_item[:fd]; end
+
+    def events=(arg); @poll_item[:events] = arg; end
+
+    def events; @poll_item[:events]; end
+  end
+end

data/lib/ffi-rzmq/poll_items.rb

@@ -1,100 +1,65 @@
+require 'forwardable'
+require 'ostruct'
 
 module ZMQ
   class PollItems
     include Enumerable
+    extend  Forwardable
+
+    def_delegators :@pollables, :size, :empty?
 
     def initialize
-      @element_size = LibZMQ::PollItem.size
-      @store = nil
-      @items = []
+      @pollables  = {}
+      @item_size  = LibZMQ::PollItem.size
+      @item_store = nil
     end
 
-    def size; @items.size; end
-
-    def empty?; @items.empty?; end
-
     def address
       clean
-      @store
+      @item_store
     end
 
-    def get index
-      unless @items.empty? || index.nil?
-        clean
-
-        # pointer arithmetic in ruby! whee!
-        pointer = @store + (@element_size * index)
-
-        # cast the memory to a PollItem
-        LibZMQ::PollItem.new pointer
-      end
+    def get pollable
+      return unless entry = @pollables[pollable]
+      clean
+      pointer = @item_store + (@item_size * entry.index)
+      item = ZMQ::PollItem.from_pointer(pointer)
+      item.pollable = pollable
+      item
     end
     alias :[] :get
 
-    def <<(obj)
+    def <<(poll_item)
       @dirty = true
-      @items << obj
+      @pollables[poll_item.pollable] = OpenStruct.new(:index => size, :data => poll_item)
     end
     alias :push :<<
-    
-    def delete sock
-      address = sock.socket.address
-      found = false
-      
-      each_with_index do |item, index|
-        if address == item[:socket].address
-          @items.delete_at index
-          found = true
-          @dirty = true
-          clean
-          break
-        end
-      end
-      
-      # these semantics are different from the usual Array#delete; returns a
-      # boolean instead of the actual item or nil
-      found
-    end
-    
-    def delete_at index
-      value = nil
-      unless @items.empty?
-        value = @items.delete_at index
+
+    def delete pollable
+      if @pollables.delete(pollable)
         @dirty = true
         clean
+        true
+      else
+        false
       end
-      
-      value
     end
 
     def each &blk
       clean
-      index = 0
-      until index >= @items.size do
-        struct = get index
-        yield struct
-        index += 1
+      @pollables.each_key do |pollable|
+        yield get(pollable)
       end
     end
 
-    def each_with_index &blk
-      clean
-      index = 0
-      until index >= @items.size do
-        struct = get index
-        yield struct, index
-        index += 1
-      end
-    end
-    
     def inspect
       clean
       str = ""
       each { |item| str << "ptr [#{item[:socket]}], events [#{item[:events]}], revents [#{item[:revents]}], " }
       str.chop.chop
     end
-    
-    def to_s(); inspect; end
+
+    def to_s; inspect; end
 
     private
 
@@ -103,18 +68,18 @@ module ZMQ
     # it is garbage collected that native memory should be automatically freed.
     def clean
       if @dirty
-        @store = FFI::MemoryPointer.new @element_size, @items.size, true
+        @item_store = FFI::MemoryPointer.new @item_size, size, true
 
-        # copy over
         offset = 0
-        @items.each do |item|
-          LibC.memcpy(@store + offset, item.pointer, @element_size)
-          offset += @element_size
+        @pollables.each_with_index do |(pollable, entry), index|
+          entry.index = index
+          LibC.memcpy(@item_store + offset, entry.data.pointer, @item_size)
+          offset += @item_size
         end
 
         @dirty = false
       end
     end
 
-  end # class PollItems
-end # module ZMQ
+  end
+end

data/lib/ffi-rzmq/socket.rb

@@ -263,15 +263,7 @@ module ZMQ
     # cause.
     #
     def send_strings parts, flags = 0
-      return -1 if !parts || parts.empty?
-      flags = NonBlocking if dontwait?(flags)
-
-      parts[0..-2].each do |part|
-        rc = send_string part, (flags | ZMQ::SNDMORE)
-        return rc unless Util.resultcode_ok?(rc)
-      end
-
-      send_string parts[-1], flags
+      send_multiple(parts, flags, :send_string)
     end
 
     # Send a sequence of messages as a multipart message out of the +parts+
@@ -289,15 +281,7 @@ module ZMQ
     # cause.
     #
     def sendmsgs parts, flags = 0
-      return -1 if !parts || parts.empty?
-      flags = NonBlocking if dontwait?(flags)
-
-      parts[0..-2].each do |part|
-        rc = sendmsg part, (flags | ZMQ::SNDMORE)
-        return rc unless Util.resultcode_ok?(rc)
-      end
-
-      sendmsg parts[-1], flags
+      send_multiple(parts, flags, :sendmsg)
     end
 
     # Sends a message. This will automatically close the +message+ for both successful
@@ -444,6 +428,23 @@ module ZMQ
 
 
     private
+    
+    def send_multiple(parts, flags, method_name)
+      if !parts || parts.empty?
+        -1
+      else
+        flags = NonBlocking if dontwait?(flags)
+        rc = nil
+        
+        parts[0..-2].each do |part|
+          rc = send(method_name, part, (flags | ZMQ::SNDMORE))
+          break unless Util.resultcode_ok?(rc)
+        end
+        
+        Util.resultcode_ok?(rc) ? send(method_name, parts[-1], flags) : rc
+      end
+      
+    end
 
     def __getsockopt__ name, array
       # a small optimization so we only have to determine the option
@@ -473,39 +474,19 @@ module ZMQ
     def sockopt_buffers option_type
       if 1 == option_type
         # int64_t or uint64_t
-        unless @longlong_cache
-          length = FFI::MemoryPointer.new :size_t
-          length.write_int 8
-          @longlong_cache = [FFI::MemoryPointer.new(:int64), length]
-        end
-
-        @longlong_cache
+        @longlong_cache ||= alloc_pointer(:int64, 8)
 
       elsif 0 == option_type
         # int, 0mq assumes int is 4-bytes
-        unless @int_cache
-          length = FFI::MemoryPointer.new :size_t
-          length.write_int 4
-          @int_cache = [FFI::MemoryPointer.new(:int32), length]
-        end
-
-        @int_cache
+        @int_cache ||= alloc_pointer(:int32, 4)
 
       elsif 2 == option_type
-        length = FFI::MemoryPointer.new :size_t
-        # could be a string of up to 255 bytes
-        length.write_int 255
-        [FFI::MemoryPointer.new(255), length]
+        # could be a string of up to 255 bytes, so allocate for worst case
+        alloc_pointer(255, 255)
 
       else
         # uh oh, someone passed in an unknown option; use a slop buffer
-        unless @int_cache
-          length = FFI::MemoryPointer.new :size_t
-          length.write_int 4
-          @int_cache = [FFI::MemoryPointer.new(:int32), length]
-        end
-
-        @int_cache
+        @int_cache ||= alloc_pointer(:int32, 4)
       end
     end
 
@@ -529,6 +510,12 @@ module ZMQ
       (NonBlocking & flags) == NonBlocking
     end
     alias :noblock? :dontwait?
+    
+    def alloc_pointer(kind, length)
+      pointer = FFI::MemoryPointer.new :size_t
+      pointer.write_int(length)
+      [FFI::MemoryPointer.new(kind), pointer]
+    end
   end # module CommonSocketBehavior
 
 

data/lib/ffi-rzmq/version.rb

@@ -1,3 +1,3 @@
 module ZMQ
-  VERSION = "0.9.6"
+  VERSION = "0.9.7"
 end

data/lib/io_extensions.rb

@@ -0,0 +1,19 @@
+class IO
+  if defined? JRUBY_VERSION
+    require 'jruby'
+    def posix_fileno
+      case self
+      when STDIN, $stdin
+        0
+      when STDOUT, $stdout
+        1
+      when STDERR, $stderr
+        2
+      else
+        JRuby.reference(self).getOpenFile.getMainStream.getDescriptor.getChannel.getFDVal
+      end
+    end
+  else
+    alias :posix_fileno :fileno
+  end
+end

data/spec/poll_spec.rb

@@ -1,10 +1,7 @@
-$: << "." # added for ruby 1.9.2 compatibilty; it doesn't include the current directory on the load path anymore
-
-require File.join(File.dirname(__FILE__), %w[spec_helper])
+require 'spec_helper'
 
 module ZMQ
 
-
   describe Poller do
 
     context "when initializing" do
@@ -12,67 +9,123 @@ module ZMQ
 
       it "should allocate a PollItems instance" do
         PollItems.should_receive(:new)
-        
         Poller.new
       end
 
-    end # context initializing
-    
-    
+    end
+
     context "#register" do
-      
+
+      let(:pollable) { mock('pollable') }
       let(:poller) { Poller.new }
-      let(:socket) { mock('socket') }
-      
-      it "should return false when given a nil socket and no file descriptor" do
-        poller.register(nil, ZMQ::POLLIN, 0).should be_false
+      let(:socket) { FFI::MemoryPointer.new(4) }
+      let(:io) { stub(:posix_fileno => fd) }
+      let(:fd) { 1 }
+
+      it "returns false when given a nil pollable" do
+        poller.register(nil, ZMQ::POLLIN).should be_false
       end
-      
-      it "should return false when given 0 for +events+ (e.g. no registration)" do
-        poller.register(socket, 0).should be_false
+
+      it "returns false when given 0 for +events+ (e.g. no registration)" do
+        poller.register(pollable, 0).should be_false
       end
-      
-      it "should return the registered event value when given a nil socket and a valid non-zero file descriptor" do
-        poller.register(nil, ZMQ::POLLIN, 1).should == ZMQ::POLLIN
+
+      it "returns the default registered event value when given a valid pollable" do
+        poller.register(pollable).should == (ZMQ::POLLIN | ZMQ::POLLOUT)
       end
-      
-      it "should return the default registered event value when given a valid socket" do
-        poller.register(socket).should == (ZMQ::POLLIN | ZMQ::POLLOUT)
+
+      it "returns the registered event value when given a pollable responding to socket (ZMQ::Socket)" do
+        pollable.should_receive(:socket).and_return(socket)
+        poller.register(pollable, ZMQ::POLLIN).should == ZMQ::POLLIN
+      end
+
+      it "returns the registered event value when given a pollable responding to file descriptor (IO, BasicSocket)" do
+        pollable.should_receive(:posix_fileno).and_return(fd)
+        poller.register(pollable, ZMQ::POLLIN).should == ZMQ::POLLIN
       end
-      
-      it "should access the raw 0mq socket" do
-        raw_socket = FFI::MemoryPointer.new(4)
-        socket.should_receive(:kind_of?).with(ZMQ::Socket).and_return(true)
-        socket.should_receive(:socket).and_return(raw_socket)
 
-        poller.register(socket)
+      it "returns the registered event value when given a pollable responding to io (SSLSocket)" do
+        pollable.should_receive(:io).and_return(io)
+        poller.register(pollable, ZMQ::POLLIN).should == ZMQ::POLLIN
       end
+
     end
-    
-    
-    context "#delete" do
-      before(:all) do
-        @context = Context.new
+
+    context "#deregister" do
+
+      let(:pollable) { mock('pollable') }
+      let(:poller) { Poller.new }
+      let(:socket) { FFI::MemoryPointer.new(4) }
+      let(:io) { stub(:posix_fileno => fd) }
+      let(:fd) { 1 }
+
+      it "returns true when deregistered pollable from event" do
+        pollable.should_receive(:socket).at_least(:once).and_return(socket)
+        poller.register(pollable)
+        poller.deregister(pollable, ZMQ::POLLIN).should be_true
       end
-      
+
+      it "returns false when pollable not registered" do
+        poller.deregister(pollable, ZMQ::POLLIN).should be_false
+      end
+
+      it "returns false when pollable not registered for deregistered event" do
+        pollable.should_receive(:socket).at_least(:once).and_return(socket)
+        poller.register(pollable, ZMQ::POLLOUT)
+        poller.deregister(pollable, ZMQ::POLLIN).should be_false
+      end
+
+      it "deletes pollable when no events left" do
+        poller.register(pollable, ZMQ::POLLIN)
+        poller.deregister(pollable, ZMQ::POLLIN).should be_true
+        poller.size.should == 0
+      end
+
+      it "deletes closed pollable responding to socket (ZMQ::Socket)" do
+        pollable.should_receive(:socket).and_return(socket)
+        poller.register(pollable)
+        pollable.should_receive(:socket).and_return(nil)
+        poller.deregister(pollable, ZMQ::POLLIN).should be_true
+        poller.size.should == 0
+      end
+
+      it "deletes closed pollable responding to fileno (IO, BasicSocket)" do
+        pollable.should_receive(:posix_fileno).and_return(fd)
+        poller.register(pollable)
+        pollable.should_receive(:closed?).and_return(true)
+        poller.deregister(pollable, ZMQ::POLLIN).should be_true
+        poller.size.should == 0
+      end
+
+      it "deletes closed pollable responding to io (SSLSocket)" do
+        pollable.should_receive(:io).at_least(:once).and_return(io)
+        poller.register(pollable)
+        io.should_receive(:closed?).and_return(true)
+        poller.deregister(pollable, ZMQ::POLLIN).should be_true
+        poller.size.should == 0
+      end
+
+    end
+
+    context "#delete" do
+
+      before(:all) { @context = Context.new }
+      after(:all)  { @context.terminate }
+
       before(:each) do
         @socket = @context.socket(XREQ)
         @socket.setsockopt(LINGER, 0)
         @poller = Poller.new
       end
-      
+
       after(:each) do
         @socket.close
       end
-      
-      after(:all) do
-        @context.terminate
-      end
-      
+
       it "should return false for an unregistered socket (i.e. not found)" do
         @poller.delete(@socket).should be_false
       end
-      
+
       it "returns true for a sucessfully deleted socket when only 1 is registered" do
         socket1 = @context.socket(REP)
         socket1.setsockopt(LINGER, 0)
@@ -81,7 +134,7 @@ module ZMQ
         @poller.delete(socket1).should be_true
         socket1.close
       end
-      
+
       it "returns true for a sucessfully deleted socket when more than 1 is registered" do
         socket1 = @context.socket(REP)
         socket2 = @context.socket(REP)
@@ -94,72 +147,130 @@ module ZMQ
         socket1.close
         socket2.close
       end
-      
+
+      it "returns true for a successfully deleted socket when the socket has been previously closed" do
+        socket1 = @context.socket(REP)
+        socket1.setsockopt(LINGER, 0)
+
+        @poller.register socket1
+        socket1.close
+        @poller.delete(socket1).should be_true
+      end
+
     end
-    
-    
+
     context "poll" do
       include APIHelper
-      
-      before(:all) do
-      end
-      
-      before(:each) do
-        # Must recreate context for each test otherwise some poll tests fail.
-        # This is likely due to a race condition in event handling when reusing
-        # the same inproc inside the same context over and over. Making a new
-        # context solves it.
-        @context = Context.new
-        endpoint = "inproc://poll_test"
-        @socket = @context.socket(DEALER)
-        @socket2 = @context.socket(ROUTER)
-        @socket.setsockopt(LINGER, 0)
-        @socket2.setsockopt(LINGER, 0)
-        @socket.bind(endpoint)
-        connect_to_inproc(@socket2, endpoint)
 
+      before(:all) { @context = Context.new }
+      after(:all)  { @context.terminate }
+
+      before(:each) do
+        endpoint = "inproc://poll_test_#{SecureRandom.hex}"
+        @sockets = [@context.socket(DEALER), @context.socket(ROUTER)]
+        @sockets.each { |s| s.setsockopt(LINGER, 0) }
+        @sockets.first.bind(endpoint)
+        connect_to_inproc(@sockets.last, endpoint)
         @poller = Poller.new
       end
-      
-      after(:each) do
-        @socket.close
-        @socket2.close
-        @context.terminate
-      end
-      
+
+      after(:each) { @sockets.each(&:close) }
+
       it "returns 0 when there are no sockets to poll" do
-        rc = @poller.poll(100)
-        rc.should be_zero
+        @poller.poll(100).should be_zero
       end
-      
+
       it "returns 0 when there is a single socket to poll and no events" do
-        @poller.register(@socket, 0)
-        rc = @poller.poll(100)
-        rc.should be_zero
+        @poller.register(@sockets.first, 0)
+        @poller.poll(100).should be_zero
       end
-      
+
       it "returns 1 when there is a read event on a socket" do
-        @poller.register_readable(@socket2)
-        
-        @socket.send_string('test')
-        rc = @poller.poll(1000)
-        rc.should == 1
+        first, last = @sockets
+        @poller.register_readable(last)
+
+        first.send_string('test')
+        @poller.poll(1000).should == 1
       end
-      
+
       it "returns 1 when there is a read event on one socket and the second socket has been removed from polling" do
-        @poller.register_readable(@socket2)
-        @poller.register_writable(@socket)
-        
-        @socket.send_string('test')
-        @poller.deregister_writable(@socket)
+        first, last = @sockets
+        @poller.register_readable(last)
+        @poller.register_writable(first)
 
-        rc = @poller.poll(1000)
-        rc.should == 1
+        first.send_string('test')
+        @poller.deregister_writable(first)
+        @poller.poll(1000).should == 1
       end
-    end # poll
 
+      it "works with BasiSocket" do
+        server = TCPServer.new("127.0.0.1", 0)
+        f, port, host, addr = server.addr
+        client = TCPSocket.new("127.0.0.1", port)
+        s = server.accept
 
-  end # describe Poll
+        @poller.register(s, ZMQ::POLLIN)
+        @poller.register(client, ZMQ::POLLOUT)
+
+        client.send("message", 0)
+
+        @poller.poll.should == 2
+        @poller.readables.should == [s]
+        @poller.writables.should == [client]
+
+        msg = s.read_nonblock(7)
+        msg.should == "message"
+      end
+
+      it "works with IO objects" do
+        r, w = IO.pipe
+        @poller.register(r, ZMQ::POLLIN)
+        @poller.register(w, ZMQ::POLLOUT)
+
+        w.write("message")
+
+        @poller.poll.should == 2
+        @poller.readables.should == [r]
+        @poller.writables.should == [w]
+
+        msg = r.read(7)
+        msg.should == "message"
+      end
+
+      it "works with SSLSocket" do
+        crt, key = %w[crt key].map { |ext| File.read(File.join(File.dirname(__FILE__), "support", "test." << ext)) }
+
+        ctx = OpenSSL::SSL::SSLContext.new
+        ctx.key  = OpenSSL::PKey::RSA.new(key)
+        ctx.cert = OpenSSL::X509::Certificate.new(crt)
+
+        server = TCPServer.new("127.0.0.1", 0)
+        f, port, host, addr = server.addr
+        client = TCPSocket.new("127.0.0.1", port)
+        s = server.accept
+
+        client = OpenSSL::SSL::SSLSocket.new(client)
+
+        server = OpenSSL::SSL::SSLSocket.new(s, ctx)
+
+        t = Thread.new { client.connect }
+        s = server.accept
+        t.join
+
+        @poller.register_readable(s)
+        @poller.register_writable(client)
+
+        client.write("message")
+
+        @poller.poll.should == 2
+        @poller.readables.should == [s]
+        @poller.writables.should == [client]
+
+        msg = s.read(7)
+        msg.should == "message"
+      end
+    end
 
+  end
 
-end # module ZMQ
+end