cztop 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: beb64c08f14c0da1a3876bd7f95f0b25ae1d8ecd
-  data.tar.gz: e6d4db01ac3823152f12a8a13ee5a2b5a08b190c
+  metadata.gz: 1619d296889181d095f1d88cf2fbf9b3f1d99f9c
+  data.tar.gz: c85c0ac08700a9f7558a9936acf8397688138248
 SHA512:
-  metadata.gz: 72cb0f766f67e77aadb269d1c1f789e9cbd44e52d2beaecfab1794c5ead455517e624bc95fcd3f28f8d98893290bca45bc7a375f537f04bd2d0d7d86f45c0959
-  data.tar.gz: e58951ec39fe151f5bc3ada5a9bfea55eb7ed2598f40386f9f7de6d82a80efb60567262ea57960dd7ea0087f0b32e7c06fccd0e4ff751d9fc7a03c5b502ed039
+  metadata.gz: 65d9cac510d5e66ae019827bd87c3959362f3e9a5ff5e4579864a2a56e5bfaef7b9de7e9b072e26c6862130b7e0b22f86c93a9f5cf0b498004c68fe1e140fc80
+  data.tar.gz: 371faea1cc8ccdb339033a2db20960cddfa9c5e40d59db4841013a06d3a72c0e70ccfe63b7e478724f46e4a963b956f045d52257f8e88787c38cbd588a836a1d

data/.travis.yml

@@ -14,14 +14,6 @@ rvm:
 env:
   # recognized by czmq-ffi-gen's ci-scripts
   - CZMQ_VERSION=HEAD ZMQ_VERSION=HEAD
-  - CZMQ_VERSION=3.0 ZMQ_VERSION=4.1
-matrix:
-  exclude:
-    # old ruby versions don't get to test bleeding edge functionality. basta.
-    - rvm: 2.2.4
-      env: CZMQ_VERSION=HEAD ZMQ_VERSION=HEAD
-    - rvm: 2.1.8
-      env: CZMQ_VERSION=HEAD ZMQ_VERSION=HEAD
 before_install:
   - PATH="/usr/lib/ccache:$PATH" # enable ccache
   - export LD_LIBRARY_PATH=$HOME/lib # custom libs (for execution)

data/CHANGES.md

@@ -1,3 +1,11 @@
+0.3.0 (13/04/2016)
+-----
+* port CZTop::Poller to zmq_poller_*() functions so it supports thread-safe
+  sockets as well
+* extract niche features to CZTop::Poller::Aggregated
+* fix taxi system example
+* drop support for CZMQ 3.0.2, ZMQ 4.0 and ZMQ 4.1
+
 0.2.1 (31/01/2016)
 -----
 * improve documentation

data/Gemfile

@@ -3,6 +3,7 @@ gemspec
 
 # useful when working on czmq-ffi-gen in parallel
 #gem "czmq-ffi-gen", git: "https://github.com/paddor/czmq-ffi-gen.git"
+#gem "rspec-core", git: "file:///Users/paddor/src/ruby/rspec-core"
 
 group :development do
   gem 'rubocop', require: false

data/README.md

@@ -27,6 +27,7 @@ the issues with them, from my point of view:
   * doesn't feel like Ruby
 * [mtortonesi/ruby-czmq](https://github.com/mtortonesi/ruby-czmq)
   * no tests
+  * no documentation
   * outdated
   * doesn't feel like Ruby
 * [chuckremes/ffi-rzmq](https://github.com/chuckremes/ffi-rzmq)
@@ -77,6 +78,7 @@ Here's an overview of the core classes:
   * [Monitor](http://www.rubydoc.info/gems/cztop/CZTop/Monitor) < Actor
   * [Proxy](http://www.rubydoc.info/gems/cztop/CZTop/Proxy) < Actor
   * [Poller](http://www.rubydoc.info/gems/cztop/CZTop/Poller)
+    * [Aggregated](http://www.rubydoc.info/gems/cztop/CZTop/Poller/Aggregated)
   * [Socket](http://www.rubydoc.info/gems/cztop/CZTop/Socket)
     * [REQ](http://www.rubydoc.info/gems/cztop/CZTop/Socket/REQ) < Socket
     * [REP](http://www.rubydoc.info/gems/cztop/CZTop/Socket/REP) < Socket
@@ -132,8 +134,8 @@ More information in the [API documentation](http://www.rubydoc.info/github/paddo
 
 You'll need:
 
-* CZMQ >= 3.0.2
-* ZMQ >= 4.0
+* CZMQ > 3.0.2 (currently built from master)
+* ZMQ >= 4.2 (currently built from master)
 
 For security mechanisms like CURVE, you'll need:
 
@@ -142,37 +144,12 @@ For security mechanisms like CURVE, you'll need:
 To install on OSX using homebrew, run:
 
     $ brew install libsodium
-    $ brew install zmq  --with-libsodium
-    $ brew install czmq
+    $ brew install zmq  --HEAD --with-libsodium
+    $ brew install czmq --HEAD
 
 If you're running Linux, go check [this page](http://zeromq.org/distro:_start)
 to get more help. Make sure to install CZMQ, not only ZMQ.
 
-**Warning**: To make use of the full feature set of CZTop (including
-CLIENT/SERVER sockets and ZMTP 3.1 heartbeats), you'll need to install both ZMQ
-and CZMQ from master, like this:
-
-    # instead of the last two commands from above
-    $ brew install zmq  --with-libsodium --HEAD
-    $ brew install czmq --HEAD
-
-See next section.
-
-### Known Issues if using the current stable releases
-
-When using ZMQ 4.1/4.0:
-* no CLIENT/SERVER sockets. Don't try.
-* no ZMTP 3.1 heartbeats. Setting the options will have no effect.
-
-When using CZMQ 3.0:
-* don't use `Certificate#[]=` to unset meta data (by passing `nil`)
-  * `zcert_unset_meta()` was added more recently for that case
-  * see [zeromq/czmq#1248](https://github.com/zeromq/czmq/pull/1248)
-* if you use Beacon, make sure you also call `Beacon#configure`. Otherwise it closes STDIN when being destroyed.
-  * see [zeromq/czmq#1281](https://github.com/zeromq/czmq/issues/1281)
-* no CLIENT/SERVER sockets. Don't try.
-* no ZMTP 3.1 heartbeats. Don't try.
-
 ### Supported Ruby versions
 
 See [.travis.yml](https://github.com/paddor/cztop/blob/master/.travis.yml) for a list of Ruby versions against which CZTop
@@ -355,8 +332,10 @@ $
     * [x] tested on CI
   * [x] ZMQ 4.1
     * [x] tested on CI
+    * as of April 2016, this isn't the case anymore
   * [x] ZMQ 4.0
     * [x] tested on CI
+    * as of March 2016, this isn't the case anymore
   * [ ] ZMQ 3.2
     * too big a pain ([d5172ab](https://github.com/paddor/czmq-ffi-gen/commit/d5172ab6db64999c50ba24f71569acf1dd45af51))
 * [x] support multiple versions of CZMQ
@@ -369,6 +348,7 @@ $
       * [x] adapt czmq-ffi-gen so it doesn't raise while `attach_function`, attach `zsys_has_curve()` instead (under same name)
     * [x] adapt test suite to skip affected test examples
     * [x] test on CI
+    * as of March, 2016, this isn't the case anymore
 * [x] port [Poller](http://www.rubydoc.info/gems/cztop/CZTop/Poller) to `zmq_poll()`
   * backwards compatible (`#add_reader`, `#add_writer`, `#wait` behave the same)
   * but in addition, it has `#readables` and `#writables` which return arrays of sockets

data/cztop.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "czmq-ffi-gen", "~> 0.7.0"
+  spec.add_runtime_dependency "czmq-ffi-gen", "~> 0.8.3"
 
   spec.add_development_dependency "bundler", "~> 1.10"
   spec.add_development_dependency "rake", "~> 10.0"

data/examples/taxi_system/broker.rb

@@ -36,11 +36,10 @@ end
 @driver_map = {} # driver name => routing ID
 Thread.new do
 
-  # CZTop::Loop (zloop) doesn't work with SERVER sockets :(
   poller = CZTop::Poller.new(@socket)
   while true
     puts "waiting for socket to become readable ..."
-    socket = poller.wait
+    socket = poller.simple_wait
     puts "socket is readable"
     msg = socket.receive
     puts "got message"

data/examples/taxi_system/client.rb

@@ -28,7 +28,7 @@ puts ">>> got #{welcome}."
 
 poller = CZTop::Poller.new(@socket)
 while true
-  socket = poller.wait
+  socket = poller.simple_wait
   message = socket.receive
   puts ">>> received message: #{message[0].inspect}"
 end

data/lib/cztop/monitor.rb

@@ -1,5 +1,3 @@
-require "pry"
-
 module CZTop
   # CZMQ monitor. Listen for socket events.
   #

data/lib/cztop/poller.rb

@@ -1,99 +1,67 @@
 module CZTop
   # A non-trivial socket poller.
   #
-  # It can poll for reading and writing, and supports getting back an array of
-  # readable/writable sockets after the call to {#wait}. The reason for this
-  # feature is to be able to use it in Celluloid::ZMQ, where in a call to
-  # Celluloid::ZMQ::Reactor#run_once all readable/writable sockets need to be
-  # processed.
+  # It can poll for reading and writing, and supports thread-safe sockets
+  # (SERVER/CLIENT/RADIO/DISH).
   #
   # This implementation is NOT based on CZMQ's +zpoller+. Reasons:
   #
   # * +zpoller+ can only poll for reading
   #
-  # It's also NOT based on +zmq_poller()+. Reasons:
-  #
-  # * +zmq_poller()+ doesn't exist in older versions of ZMQ < 4.2
-  #
-  # Possible future implementation on +zmq_poller()+ might work like this, to
-  # support getting an array of readable/writable sockets:
-  #
-  # * in {#wait}, poll with normal timeout
-  # * then poll again with zero timeout until no more sockets, accumulate
-  #   results
-  #
-  # = Limitations
-  #
-  # This poller can't poll for writing on CLIENT/SERVER sockets.
-  # Implementation could be adapted to support them using
-  # {CZTop::Poller::ZPoller}, at least for reading. But it'd make the code
-  # ugly.
-  #
   class Poller
     include ::CZMQ::FFI
 
     # @param readers [Socket, Actor] sockets to poll for input
     def initialize(*readers)
-      @readers = {}
-      @writers = {}
-      @readables = []
-      @writables = []
-      @rebuild_needed = true
-      readers.each { |r| add_reader(r) }
-    end
-
-    # @return [Array<CZTop::Socket>] registered reader sockets
-    def readers
-      @readers.values
-    end
-
-    # @return [Array<CZTop::Socket>] registered writer sockets
-    def writers
-      @writers.values
+      @sockets = {} # needed to return the same socket objects
+      @events = {} # event masks for each socket
+      @poller_ptr = ZMQ.poller_new
+      ObjectSpace.define_finalizer(@poller_ptr,
+        Proc.new do
+          ptr_ptr = ::FFI::MemoryPointer.new :pointer
+          ptr_ptr.write_pointer(@poller_ptr)
+          ZMQ.poller_destroy(ptr_ptr)
+        end)
+      @event_ptr = FFI::MemoryPointer.new(ZMQ::PollerEvent)
+      readers.each { |r| add(r) }
     end
 
     # Adds a socket to be polled for reading.
     # @param socket [Socket, Actor] the socket
+    # @param events [Integer] events you're interested in (see constants in
+    #   {ZMQ}
     # @return [void]
     # @raise [ArgumentError] if it's not a socket
-    def add_reader(socket)
-      raise ArgumentError unless socket.is_a?(Socket) || socket.is_a?(Actor)
-      ptr = Zsock.resolve(socket) # get low-level handle
-      @readers[ptr.to_i] = socket
-      @rebuild_needed = true
-    end
-
-    # Removes a previously registered reader socket. Won't raise if you're
-    # trying to remove a socket that's not registered.
-    # @param socket [Socket, Actor] the socket
-    # @return [void]
-    # @raise [ArgumentError] if it's not a socket
-    def remove_reader(socket)
-      raise ArgumentError unless socket.is_a?(Socket) || socket.is_a?(Actor)
-      ptr = Zsock.resolve(socket) # get low-level handle
-      @readers.delete(ptr.to_i) and @rebuild_needed = true
+    def add(socket, events = ZMQ::POLLIN)
+      ptr = ptr_for_socket(socket)
+      rc = ZMQ.poller_add(@poller_ptr, ptr, nil, events)
+      HasFFIDelegate.raise_zmq_err if rc == -1
+      remember_socket(socket, events)
     end
 
-    # Adds a socket to be polled for writing.
+    # Modifies the events of interest for the given socket.
     # @param socket [Socket, Actor] the socket
+    # @param events [Integer] events you're interested in (see constants in
+    #   {ZMQ}
     # @return [void]
     # @raise [ArgumentError] if it's not a socket
-    def add_writer(socket)
-      raise ArgumentError unless socket.is_a?(Socket) || socket.is_a?(Actor)
-      ptr = Zsock.resolve(socket) # get low-level handle
-      @writers[ptr.to_i] = socket
-      @rebuild_needed = true
+    def modify(socket, events)
+      ptr = ptr_for_socket(socket)
+      rc = ZMQ.poller_modify(@poller_ptr, ptr, events)
+      HasFFIDelegate.raise_zmq_err if rc == -1
+      remember_socket(socket, events)
     end
 
-    # Removes a previously registered writer socket. Won't raise if you're
+    # Removes a previously registered socket. Won't raise if you're
     # trying to remove a socket that's not registered.
     # @param socket [Socket, Actor] the socket
     # @return [void]
     # @raise [ArgumentError] if it's not a socket
-    def remove_writer(socket)
-      raise ArgumentError unless socket.is_a?(Socket) || socket.is_a?(Actor)
-      ptr = Zsock.resolve(socket) # get low-level handle
-      @writers.delete(ptr.to_i) and @rebuild_needed = true
+    def remove(socket)
+      ptr = ptr_for_socket(socket)
+      rc = ZMQ.poller_remove(@poller_ptr, ptr)
+      HasFFIDelegate.raise_zmq_err if rc == -1
+      forget_socket(socket)
     end
 
     # Waits for registered sockets to become readable or writable, depending
@@ -101,236 +69,378 @@ module CZTop
     #
     # @param timeout [Integer] how long to wait in ms, or 0 to avoid blocking,
     #   or -1 to wait indefinitely
-    # @return [Socket, Actor] the first readable socket
+    # @return [Event] the first event of interest
     # @return [nil] if the timeout expired or
-    # @raise [Interrupt] if the timeout expired or
+    # @raise [SystemCallError] if this failed
     def wait(timeout = -1)
-      rebuild if @rebuild_needed
-      @readables = @writables = nil
-
-      num = ZMQ.poll(@items_ptr, @nitems, timeout)
-      HasFFIDelegate.raise_zmq_err if num == -1
+      rc = ZMQ.poller_wait(@poller_ptr, @event_ptr, timeout)
+      if rc == -1
+        if CZMQ::FFI::Errors.errno != Errno::ETIMEDOUT::Errno
+          HasFFIDelegate.raise_zmq_err
+        end
+        return nil
+      end
+      return Event.new(self, @event_ptr)
+    end
 
-      return nil if num == 0
-      return readables[0] if readables.any?
+    # Simpler version of {#wait}, which just returns the first socket of
+    # interest, if any. This is useful if you either have only reader sockets,
+    # or only have writer sockets.
+    # @param timeout [Integer] how long to wait in ms, or 0 to avoid blocking,
+    #   or -1 to wait indefinitely
+    # @return [Socket, Actor] first socket of interest
+    # @return [nil] if timeout expired
+    # @raise [SystemCallError] if this failed
+    def simple_wait(timeout = -1)
+      event = wait(timeout)
+      return event.socket if event
+    end
 
-      # TODO: handle CLIENT/SERVER sockets using ZPoller
-#      if threadsafe_sockets.any?
-#        zpoller.wait(0)
-#      end
+    # @param ptr [FFI::Pointer] pointer to the socket
+    # @return [Socket, Actor] socket corresponding to given pointer
+    def socket_for_ptr(ptr)
+      @sockets[ptr.to_i] or
+        # NOTE: This should never happen, since #wait will return nil if
+        # +zpoller_wait+ returned NULL. But it's better to fail early in case
+        # it ever returns a wrong pointer.
+        HasFFIDelegate.raise_zmq_err(
+          "no socket known for pointer #{ptr.inspect}")
     end
 
-    # @return [Array<CZTop::Socket>] readable sockets (memoized)
-    def readables
-      @readables ||= @reader_items.select(&:readable?).map do |item|
-        ptr = item[:socket]
-        @readers[ ptr.to_i ]
-      end
+    # @return [Array<CZTop::Socket>] all sockets registered with this poller
+    # @note The actual events registered for each sockets don't matter.
+    def sockets
+      @sockets.values
     end
 
-    # @return [Array<CZTop::Socket>] writable sockets (memoized)
-    def writables
-      @writables ||= @writer_items.select(&:writable?).map do |item|
-        ptr = item[:socket]
-        @writers[ ptr.to_i ]
-      end
+    def event_mask_for_socket(socket)
+      @events[socket] or
+        raise "no event mask known for socket %p" % socket
     end
 
     private
 
-    # Rebuilds the list of +poll_item_t+.
-    # @return [void]
-    def rebuild
-      @nitems = @readers.size + @writers.size
-      @items_ptr = FFI::MemoryPointer.new(ZMQ::PollItem, @nitems)
-      @items_ptr.autorelease = true
-
-      # memory addresses
-      mem = Enumerator.new do |y|
-        @nitems.times { |i| y << @items_ptr + i * ZMQ::PollItem.size }
-      end
+    # @param socket [Socket, Actor] the socket
+    # @return [FFI::Pointer] low-level handle
+    # @raise [ArgumentError] if argument is not a socket
+    def ptr_for_socket(socket)
+      raise ArgumentError unless socket.is_a?(Socket) || socket.is_a?(Actor)
+      Zsock.resolve(socket)
+    end
 
-      @reader_items = @readers.map{|_,s| new_item(mem.next, s, ZMQ::POLLIN) }
-      @writer_items = @writers.map{|_,s| new_item(mem.next, s, ZMQ::POLLOUT) }
+    def remember_socket(socket, events)
+      @sockets[ptr_for_socket(socket).to_i] = socket
+      @events[socket] = events
+    end
 
-      @rebuild_needed = false
+    def forget_socket(socket)
+      @sockets.delete(ptr_for_socket(socket).to_i)
+      @events.delete(socket)
     end
 
-    # @param address [FFI::Pointer] allocated memory address for this item
-    # @param socket [CZTop::Socket] socket we're interested in
-    # @param events [Integer] the events we're interested in
-    # @return [ZMQ::PollItem] a new item for
-    def new_item(address, socket, events)
-      item = ZMQ::PollItem.new(address)
-      item[:socket] = Zsock.resolve(socket)
-      item[:fd] = 0
-      item[:events] = events
-      item[:revents] = 0
-      item
+    # Represents an event returned by {CZTop::Poller#wait}. This is useful to
+    # find out whether the associated socket is now readable or writable, in
+    # case you're interested in both. For a simpler variant, check out
+    # {CZTop::Poller#simple_wait}.
+    class Event
+      # @param poller [CZTop::Poller] the poller instance
+      # @param event_ptr [FFI::Pointer] pointer to the memory allocated for
+      #   the event's data (a +zmq_poller_event_t+)
+      def initialize(poller, event_ptr)
+        @poller = poller
+        @poller_event = ZMQ::PollerEvent.new(event_ptr)
+      end
+
+      # @return [Socket, Actor] the associated socket
+      def socket
+        @socket ||= @poller.socket_for_ptr(@poller_event[:socket])
+      end
+
+      # @return [Boolean] whether it's readable
+      def readable?
+        @poller_event.readable?
+      end
+
+      # @return [Boolean] whether it's writable
+      def writable?
+        @poller_event.writable?
+      end
     end
+  end
 
-    # CZTop's interface to the low-level +zmq_poll()+ function.
-    module ZMQ
+  # This is a poller which is able to provide a list of readable and a list
+  # of writable sockets. This is useful for when you need to process socket
+  # events in batch, rather than one per event loop iteration.
+  #
+  # In particular, this is needed in Celluloid::ZMQ, where in a call to
+  # Celluloid::ZMQ::Reactor#run_once all readable/writable sockets need to
+  # be processed.
+  #
+  # = Implementation
+  #
+  # It wraps a {CZTop::Poller} and just does the following to support
+  # getting an array of readable/writable sockets:
+  #
+  # * in {#wait}, poll with given timeout
+  # * in case there was an event, poll again with zero timeout until no more
+  #   sockets
+  # * accumulate results into two lists
+  #
+  class Poller::Aggregated
 
-      POLL    = 1
-      POLLIN  = 1
-      POLLOUT = 2
-      POLLERR = 4
+    # @return [CZTop::Poller.new] the associated (regular) poller
+    attr_reader :poller
 
-      extend ::FFI::Library
-      lib_name = 'libzmq'
-      lib_paths = ['/usr/local/lib', '/opt/local/lib', '/usr/lib64']
-        .map { |path| "#{path}/#{lib_name}.#{::FFI::Platform::LIBSUFFIX}" }
-      ffi_lib lib_paths + [lib_name]
+    # @return [Array<CZTop::Socket>] readable sockets
+    attr_reader :readables
 
-      # Represents a struct of type +zmq_pollitem_t+.
-      class PollItem < FFI::Struct
-        ##
-        # shamelessly taken from https://github.com/mtortonesi/ruby-czmq-ffi
-        #
+    # @return [Array<CZTop::Socket>] writable sockets
+    attr_reader :writables
 
+    # Initializes the aggregated poller.
+    # @param poller [CZTop::Poller] the wrapped poller
+    def initialize(poller = CZTop::Poller.new)
+      @readables = []
+      @writables = []
+      @poller = poller
+    end
 
-        FD_TYPE = if FFI::Platform::IS_WINDOWS && FFI::Platform::ADDRESS_SIZE == 64
-          # On Windows, zmq.h defines fd as a SOCKET, which is 64 bits on x64.
-          :uint64
-        else
-          :int
-        end
+    # Forgets all previous event information (which sockets are
+    # readable/writable) and waits for events anew. After getting the first
+    # event, {CZTop::Poller#wait} is called again with a zero-timeout to get
+    # all pending events to extract them into the aggregated lists of
+    # readable and writable sockets.
+    #
+    # For every event, the corresponding event mask flag is disabled for the
+    # associated socket, so it won't turn up again. Finally, all event masks
+    # are restored to what they were before the call to this method.
+    #
+    # @param timeout [Integer] how long to wait in ms, or 0 to avoid blocking,
+    #   or -1 to wait indefinitely
+    # @return [Boolean] whether there have been any events
+    def wait(timeout = -1)
+      @readables = []
+      @writables = []
+      @event_masks = {}
 
-        layout  :socket,  :pointer,
-                :fd,      FD_TYPE,
-                :events,  :short,
-                :revents, :short
+      if event = @poller.wait(timeout)
+        extract(event)
 
-        # @return [Boolean] whether the socket is readable
-        def readable?
-          (self[:revents] & POLLIN) > 0
+        # get all other pending events, if any, but no more blocking
+        while event = @poller.wait(0)
+          extract(event)
         end
 
-        # @return [Boolean] whether the socket is writable
-        def writable?
-          (self[:revents] & POLLOUT) > 0
-        end
+        restore_event_masks
+        return true
       end
-
-      opts = {
-        blocking: true  # only necessary on MRI to deal with the GIL.
-      }
-
-      #ZMQ_EXPORT int  zmq_poll (zmq_pollitem_t *items, int nitems, long timeout);
-      attach_function :poll, :zmq_poll, [:pointer, :int, :long], :int, **opts
+      return false
     end
 
-    # This is the trivial poller based on zpoller. It only supports polling
-    # for reading, but it also supports doing that on CLIENT/SERVER sockets,
-    # which is useful for {CZTop::Poller}.
+    private
+
+    # Extracts the event information, adds the socket to the correct list(s)
+    # and modifies the socket's event mask for the socket to not turn up
+    # again during the next call(s) to {CZTop::Poller#wait} within {#wait}.
     #
-    # @see http://api.zeromq.org/czmq3-0:zpoller
-    class ZPoller
-      include HasFFIDelegate
-      extend CZTop::HasFFIDelegate::ClassMethods
-      include ::CZMQ::FFI
-
-      # Initializes the Poller. At least one reader has to be given.
-      # @param reader [Socket, Actor] socket to poll for input
-      # @param readers [Socket, Actor] any additional sockets to poll for input
-      def initialize(reader, *readers)
-        @sockets = {} # to keep references and return same instances
-        ptr = Zpoller.new(reader,
-                          *readers.flat_map {|r| [ :pointer, r ] },
-                          :pointer, nil)
-        attach_ffi_delegate(ptr)
-        remember_socket(reader)
-        readers.each { |r| remember_socket(r) }
+    # @param event [CZTop::Poller::Event]
+    # @return [void]
+    def extract(event)
+      event_mask = poller.event_mask_for_socket(event.socket)
+      @event_masks[event.socket] = event_mask
+      if event.readable?
+        @readables << event.socket
+        event_mask &= 0xFFFF ^ CZTop::Poller::ZMQ::POLLIN
       end
-
-      # Adds another reader socket to the poller.
-      # @param reader [Socket, Actor] socket to poll for input
-      # @return [void]
-      # @raise [SystemCallError] if this fails
-      def add(reader)
-        rc = ffi_delegate.add(reader)
-        raise_zmq_err("unable to add socket %p" % reader) if rc == -1
-        remember_socket(reader)
+      if event.writable?
+        @writables << event.socket
+        event_mask &= 0xFFFF ^ CZTop::Poller::ZMQ::POLLOUT
       end
+      poller.modify(event.socket, event_mask)
+    end
 
-      # Removes a reader socket from the poller.
-      # @param reader [Socket, Actor] socket to remove
-      # @return [void]
-      # @raise [ArgumentError] if socket was invalid, e.g. it wasn't registered
-      #   in this poller
-      # @raise [SystemCallError] if this fails for another reason
-      def remove(reader)
-        rc = ffi_delegate.remove(reader)
-        raise_zmq_err("unable to remove socket %p" % reader) if rc == -1
-        forget_socket(reader)
+    # Restores the event mask for all registered sockets to the state they
+    # were before the call to {#wait}.
+    # @return [void]
+    def restore_event_masks
+      @event_masks.each do |socket, mask|
+        poller.modify(socket, mask)
       end
+    end
+  end
 
-      # Wait and return the first socket that becomes readable.
-      # @param timeout [Integer] how long to wait in ms, or 0 to avoid blocking,
-      #   or -1 to wait indefinitely
-      # @return [Socket, Actor]
-      # @return [nil] if the timeout expired or
-      # @raise [Interrupt] if the timeout expired or
-      def wait(timeout = -1)
-        ptr = ffi_delegate.wait(timeout)
-        if ptr.null?
-          raise Interrupt if ffi_delegate.terminated
-          return nil
-        end
-        return socket_by_ptr(ptr)
-      end
+  # CZTop's interface to the low-level +zmq_poll()+ function.
+  module Poller::ZMQ
+
+    POLL    = 1
+    POLLIN  = 1
+    POLLOUT = 2
+    POLLERR = 4
+
+    extend ::FFI::Library
+    lib_name = 'libzmq'
+    lib_paths = ['/usr/local/lib', '/opt/local/lib', '/usr/lib64']
+      .map { |path| "#{path}/#{lib_name}.#{::FFI::Platform::LIBSUFFIX}" }
+    ffi_lib lib_paths + [lib_name]
 
-      # Tells the zpoller to ignore interrupts. By default, {#wait} will return
-      # immediately if it detects an interrupt (when +zsys_interrupted+ is set
-      # to something other than zero). Calling this method will supress this
-      # behavior.
-      # @return [void]
-      def ignore_interrupts
-        ffi_delegate.ignore_interrupts
+    # This represents a +zmq_poller_event_t+ as in:
+    #
+    #   typedef struct zmq_poller_event_t
+    #   {
+    #       void *socket;
+    #       int fd;
+    #       void *user_data;
+    #       short events;
+    #   } zmq_poller_event_t;
+    class PollerEvent < FFI::Struct
+      layout :socket, :pointer,
+             :fd, :int,
+             :user_data, :pointer,
+             :events, :short
+
+      # @return [Boolean] whether the socket is readable
+      def readable?
+        (self[:events] & POLLIN) > 0
       end
 
-      # By default the poller stops if the process receives a SIGINT or SIGTERM
-      # signal. This makes it impossible to shut-down message based architectures
-      # like zactors. This method lets you switch off break handling. The default
-      # nonstop setting is off (false).
-      #
-      # Setting this will cause {#wait} to never raise.
-      #
-      # @param flag [Boolean] whether the poller should run nonstop
-      def nonstop=(flag)
-        ffi_delegate.set_nonstop(flag)
+      # @return [Boolean] whether the socket is writable
+      def writable?
+        (self[:events] & POLLOUT) > 0
       end
+    end
 
-      private
+#ZMQ_EXPORT void *zmq_poller_new (void);
+#ZMQ_EXPORT int  zmq_poller_destroy (void **poller_p);
+#ZMQ_EXPORT int  zmq_poller_add (void *poller, void *socket, void *user_data, short events);
+#ZMQ_EXPORT int  zmq_poller_modify (void *poller, void *socket, short events);
+#ZMQ_EXPORT int  zmq_poller_remove (void *poller, void *socket);
+#ZMQ_EXPORT int  zmq_poller_wait (void *poller, zmq_poller_event_t *event, long timeout);
+
+    opts = {
+      blocking: true  # only necessary on MRI to deal with the GIL.
+    }
+    attach_function :poller_new, :zmq_poller_new, [], :pointer, **opts
+    attach_function :poller_destroy, :zmq_poller_destroy,
+      [:pointer], :int, **opts
+    attach_function :poller_add, :zmq_poller_add,
+      [:pointer, :pointer, :pointer, :short], :int, **opts
+    attach_function :poller_modify, :zmq_poller_modify,
+      [:pointer, :pointer, :short], :int, **opts
+    attach_function :poller_remove, :zmq_poller_remove,
+      [:pointer, :pointer], :int, **opts
+    attach_function :poller_wait, :zmq_poller_wait,
+      [:pointer, :pointer, :long], :int, **opts
+  end
 
-      # Remembers the socket so a call to {#wait} can return with the exact same
-      # instance of {Socket}, and it also makes sure the socket won't get
-      # GC'd.
-      # @param socket [Socket, Actor] the socket instance to remember
-      # @return [void]
-      def remember_socket(socket)
-        @sockets[socket.to_ptr.to_i] = socket
-      end
+  # This is the trivial poller based on zpoller. It only supports polling
+  # for reading, but it also supports doing that on CLIENT/SERVER sockets,
+  # which is useful for {CZTop::Poller}.
+  #
+  # @see http://api.zeromq.org/czmq3-0:zpoller
+  class Poller::ZPoller
+    include HasFFIDelegate
+    extend CZTop::HasFFIDelegate::ClassMethods
+    include ::CZMQ::FFI
 
-      # Forgets the socket because it has been removed from the poller.
-      # @param socket [Socket, Actor] the socket instance to forget
-      # @return [void]
-      def forget_socket(socket)
-        @sockets.delete(socket.to_ptr.to_i)
-      end
+    # Initializes the Poller. At least one reader has to be given.
+    # @param reader [Socket, Actor] socket to poll for input
+    # @param readers [Socket, Actor] any additional sockets to poll for input
+    def initialize(reader, *readers)
+      @sockets = {} # to keep references and return same instances
+      ptr = Zpoller.new(reader,
+                        *readers.flat_map {|r| [ :pointer, r ] },
+                        :pointer, nil)
+      attach_ffi_delegate(ptr)
+      remember_socket(reader)
+      readers.each { |r| remember_socket(r) }
+    end
+
+    # Adds another reader socket to the poller.
+    # @param reader [Socket, Actor] socket to poll for input
+    # @return [void]
+    # @raise [SystemCallError] if this fails
+    def add(reader)
+      rc = ffi_delegate.add(reader)
+      raise_zmq_err("unable to add socket %p" % reader) if rc == -1
+      remember_socket(reader)
+    end
+
+    # Removes a reader socket from the poller.
+    # @param reader [Socket, Actor] socket to remove
+    # @return [void]
+    # @raise [ArgumentError] if socket was invalid, e.g. it wasn't registered
+    #   in this poller
+    # @raise [SystemCallError] if this fails for another reason
+    def remove(reader)
+      rc = ffi_delegate.remove(reader)
+      raise_zmq_err("unable to remove socket %p" % reader) if rc == -1
+      forget_socket(reader)
+    end
 
-      # Gets the previously remembered socket associated to the given pointer.
-      # @param ptr [FFI::Pointer] the pointer to a socket
-      # @return [Socket, Actor] the socket associated to the given pointer
-      # @raise [SystemCallError] if no socket is registered under given pointer
-      def socket_by_ptr(ptr)
-        @sockets[ptr.to_i] or
-          # NOTE: This should never happen, since #wait will return nil if
-          # +zpoller_wait+ returned NULL. But it's better to fail early in case
-          # it ever returns a wrong pointer.
-          raise_zmq_err("no socket known for pointer #{ptr.inspect}")
+    # Waits and returns the first socket that becomes readable.
+    # @param timeout [Integer] how long to wait in ms, or 0 to avoid
+    #   blocking, or -1 to wait indefinitely
+    # @return [Socket, Actor] first socket of interest
+    # @return [nil] if the timeout expired or
+    # @raise [Interrupt] if the timeout expired or
+    def wait(timeout = -1)
+      ptr = ffi_delegate.wait(timeout)
+      if ptr.null?
+        raise Interrupt if ffi_delegate.terminated
+        return nil
       end
+      return socket_by_ptr(ptr)
+    end
+
+    # Tells the zpoller to ignore interrupts. By default, {#wait} will return
+    # immediately if it detects an interrupt (when +zsys_interrupted+ is set
+    # to something other than zero). Calling this method will supress this
+    # behavior.
+    # @return [void]
+    def ignore_interrupts
+      ffi_delegate.ignore_interrupts
+    end
+
+    # By default the poller stops if the process receives a SIGINT or SIGTERM
+    # signal. This makes it impossible to shut-down message based architectures
+    # like zactors. This method lets you switch off break handling. The default
+    # nonstop setting is off (false).
+    #
+    # Setting this will cause {#wait} to never raise.
+    #
+    # @param flag [Boolean] whether the poller should run nonstop
+    def nonstop=(flag)
+      ffi_delegate.set_nonstop(flag)
+    end
+
+    private
+
+    # Remembers the socket so a call to {#wait} can return with the exact same
+    # instance of {Socket}, and it also makes sure the socket won't get
+    # GC'd.
+    # @param socket [Socket, Actor] the socket instance to remember
+    # @return [void]
+    def remember_socket(socket)
+      @sockets[socket.to_ptr.to_i] = socket
+    end
+
+    # Forgets the socket because it has been removed from the poller.
+    # @param socket [Socket, Actor] the socket instance to forget
+    # @return [void]
+    def forget_socket(socket)
+      @sockets.delete(socket.to_ptr.to_i)
+    end
+
+    # Gets the previously remembered socket associated to the given pointer.
+    # @param ptr [FFI::Pointer] the pointer to a socket
+    # @return [Socket, Actor] the socket associated to the given pointer
+    # @raise [SystemCallError] if no socket is registered under given pointer
+    def socket_by_ptr(ptr)
+      @sockets[ptr.to_i] or
+        # NOTE: This should never happen, since #wait will return nil if
+        # +zpoller_wait+ returned NULL. But it's better to fail early in case
+        # it ever returns a wrong pointer.
+        raise_zmq_err("no socket known for pointer #{ptr.inspect}")
     end
   end
 end

data/lib/cztop/version.rb

@@ -1,3 +1,3 @@
 module CZTop
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

data/lib/cztop/z85.rb

@@ -43,7 +43,7 @@ module CZTop
 
     def initialize
       attach_ffi_delegate(CZMQ::FFI::Zarmour.new)
-      ffi_delegate.set_mode(:mode_z85)
+      ffi_delegate.set_mode(CZMQ::FFI::Zarmour::MODE_Z85)
     end
 
     # Encodes to Z85.
@@ -70,32 +70,10 @@ module CZTop
     # @raise [SystemCallError] if this fails
     def decode(input)
       raise ArgumentError, "wrong input length" if input.bytesize % 5 > 0
-      FFI::MemoryPointer.new(:size_t) do |size_ptr|
-        buffer_ptr = ffi_delegate.decode(input, size_ptr)
-        raise_zmq_err if buffer_ptr.null?
-        decoded_string = buffer_ptr.read_string(_size(size_ptr) - 1)
-        return decoded_string
-      end
-    end
-
-    private
-
-    # Gets correct size, depending on the platform.
-    # @return [Integer]
-    # @see https://github.com/ffi/ffi/issues/398
-    # @see https://github.com/ffi/ffi/issues/333
-    def _size(size_ptr)
-      if RUBY_ENGINE == "jruby"
-        # NOTE: JRuby FFI doesn't have #read_uint64, nor does it have
-        # Pointer::SIZE
-        return size_ptr.read_ulong_long
-      end
-
-      if ::FFI::Pointer::SIZE == 8 # 64 bit
-        size_ptr.read_uint64
-      else
-        size_ptr.read_uint32
-      end
+      zchunk = ffi_delegate.decode(input)
+      raise_zmq_err if zchunk.null?
+      decoded_string = zchunk.data.read_string(zchunk.size - 1)
+      return decoded_string
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cztop
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Patrik Wenger
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-01-31 00:00:00.000000000 Z
+date: 2016-04-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: czmq-ffi-gen
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.7.0
+        version: 0.8.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.7.0
+        version: 0.8.3
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement