ffi-rzmq 0.9.3 → 0.9.6

data/examples/v3api/publish_subscribe.rb

@@ -71,7 +71,7 @@ assert(s4.recv_string(body)) if s4.more_parts?
 puts "s4 received topic [#{topic}], body [#{body}]"
 
 s5_string = ''
-rc = s5.recv_string(s5_string, ZMQ::DONTWAIT)
+rc = s5.recv_string(s5_string, ZMQ::NonBlocking)
 eagain = (rc == -1 && ZMQ::Util.errno == ZMQ::EAGAIN)
 puts(eagain ? "s5 received no messages" : "s5 FAILED")
 

data/examples/v3api/reqrep_poll.rb

@@ -38,7 +38,7 @@ until @done do
     payload = "#{ '3' * 1024 }"
 
     puts "sending payload nonblocking"
-    assert(s1.send_string(payload, ZMQ::DONTWAIT))
+    assert(s1.send_string(payload, ZMQ::NonBlocking))
     @unsent = false
   end
 
@@ -46,7 +46,7 @@ until @done do
   if Time.now - start_time > 1
     poller.readables.each do |sock|
       received_msg = ''
-      assert(sock.recv_string(received_msg, ZMQ::DONTWAIT))
+      assert(sock.recv_string(received_msg, ZMQ::NonBlocking))
 
       puts "message received [#{received_msg}]"
       @done = true

data/examples/v3api/sub.rb

@@ -0,0 +1,69 @@
+
+require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'ffi-rzmq')
+
+#if ARGV.length != 3
+#  puts "usage: ruby local_throughtput.rb <bind-to> <message-size> <message-count>"
+#  Process.exit
+#end
+p ZMQ::Util.version
+
+def assert(rc)
+  raise "Last API call failed at #{caller(1)}" unless rc >= 0
+end
+
+bind_to = ARGV[0]
+message_size = ARGV[1].to_i
+message_count = ARGV[2].to_i
+sleep_time = ARGV[3].to_f
+
+begin
+  ctx = ZMQ::Context.new
+  s = ZMQ::Socket.new(ctx.pointer, ZMQ::SUB)
+rescue ContextError => e
+  STDERR.puts "Failed to allocate context or socket!"
+  raise
+end
+
+#assert(s.setsockopt(ZMQ::LINGER, 100))
+assert(s.setsockopt(ZMQ::SUBSCRIBE, ""))
+assert(s.setsockopt(ZMQ::RCVHWM, 20))
+#assert(s.setsockopt(ZMQ::RCVHWM, 0))
+#assert(s.setsockopt(ZMQ::SNDHWM, 0))
+
+assert(s.connect(bind_to))
+sleep 1
+
+msg = ZMQ::Message.new
+msg = ''
+assert(s.recv_string(msg))
+raise unless msg.to_i == 0
+
+start_time = Time.now
+
+i = 1
+while i < message_count
+  assert(s.recv_string(msg))
+  msg_i = msg.to_i
+  puts "missed [#{msg_i - i}] messages"
+  i = msg_i
+  sleep(sleep_time)
+end
+
+end_time = Time.now
+
+elapsed = (end_time.to_f - start_time.to_f) * 1000000
+if elapsed == 0
+  elapsed = 1
+end
+
+throughput = message_count * 1000000 / elapsed
+megabits = throughput * message_size * 8 / 1000000
+
+puts "message size: %i [B]" % message_size
+puts "message count: %i" % message_count
+puts "mean throughput: %i [msg/s]" % throughput
+puts "mean throughput: %.3f [Mb/s]" % megabits
+
+assert(s.close)
+
+ctx.terminate

data/examples/v3api/xreqxrep_poll.rb

@@ -43,7 +43,7 @@ until @done do
 
     5.times do |i|
       payload = "#{ i.to_s * 40 }"
-      assert(s1.send_string(payload, ZMQ::DONTWAIT))
+      assert(s1.send_string(payload, ZMQ::NonBlocking))
     end
     @unsent = false
   end
@@ -54,12 +54,12 @@ until @done do
 
       if sock.identity =~ /xrep/
         routing_info = ''
-        assert(sock.recv_string(routing_info, ZMQ::DONTWAIT))
+        assert(sock.recv_string(routing_info, ZMQ::NonBlocking))
         puts "routing_info received [#{routing_info}] on socket.identity [#{sock.identity}]"
       else
         routing_info = nil
         received_msg = ''
-        assert(sock.recv_string(received_msg, ZMQ::DONTWAIT))
+        assert(sock.recv_string(received_msg, ZMQ::NonBlocking))
 
         # skip to the next iteration if received_msg is nil; that means we got an EAGAIN
         next unless received_msg
@@ -68,13 +68,13 @@ until @done do
 
       while sock.more_parts? do
         received_msg = ''
-        assert(sock.recv_string(received_msg, ZMQ::DONTWAIT))
+        assert(sock.recv_string(received_msg, ZMQ::NonBlocking))
 
         puts "message received [#{received_msg}]"
       end
 
       puts "kick back a reply"
-      assert(sock.send_string(routing_info, ZMQ::SNDMORE | ZMQ::DONTWAIT)) if routing_info
+      assert(sock.send_string(routing_info, ZMQ::SNDMORE | ZMQ::NonBlocking)) if routing_info
       time = Time.now.strftime "%Y-%m-%dT%H:%M:%S.#{Time.now.usec}"
       reply = "reply " + sock.identity.upcase + " #{time}"
       puts "sent reply [#{reply}], #{time}"

data/ffi-rzmq.gemspec

@@ -6,12 +6,12 @@ Gem::Specification.new do |s|
   s.name        = "ffi-rzmq"
   s.version     = ZMQ::VERSION
   s.authors     = ["Chuck Remes"]
-  s.email       = ["cremes@mac.com"]
+  s.email       = ["git@chuckremes.com"]
   s.homepage    = "http://github.com/chuckremes/ffi-rzmq"
   s.summary     = %q{This gem wraps the ZeroMQ (0mq) networking library using Ruby FFI (foreign function interface).}
   s.description = %q{This gem wraps the ZeroMQ networking library using the ruby FFI (foreign
 function interface). It's a pure ruby wrapper so this gem can be loaded
-and run by any ruby runtime that supports FFI. That's all of them:
+and run by any ruby runtime that supports FFI. That's all of them -
 MRI 1.9.x, Rubinius and JRuby.}
 
   s.rubyforge_project = "ffi-rzmq"

data/lib/ffi-rzmq/constants.rb

@@ -1,7 +1,7 @@
 module ZMQ
   # Set up all of the constants that are *common* to all API
   # versions
-  
+
   #  Socket types
   PAIR = 0
   PUB = 1
@@ -41,6 +41,8 @@ module ZMQ
   RECONNECT_IVL = 18
   BACKLOG = 19
   RECONNECT_IVL_MAX = 21
+  RCVTIMEO = 27
+  SNDTIMEO = 28
 
   #  Send/recv options
   SNDMORE = 2
@@ -58,13 +60,14 @@ module ZMQ
   ENOMEM = Errno::ENOMEM::Errno
   ENODEV = Errno::ENODEV::Errno
   EFAULT = Errno::EFAULT::Errno
+  EINTR  = Errno::EINTR::Errno
 
   # ZMQ errors
   HAUSNUMERO     = 156384712
-  EMTHREAD       = (HAUSNUMERO + 50)
   EFSM           = (HAUSNUMERO + 51)
   ENOCOMPATPROTO = (HAUSNUMERO + 52)
   ETERM          = (HAUSNUMERO + 53)
+  EMTHREAD       = (HAUSNUMERO + 54)
 
   # Rescue unknown constants and use the ZeroMQ defined values
   # Usually only happens on Windows though some don't resolve on
@@ -78,7 +81,20 @@ module ZMQ
   ECONNREFUSED    = Errno::ECONNREFUSED::Errno rescue (HAUSNUMERO + 7)
   EINPROGRESS     = Errno::EINPROGRESS::Errno rescue (HAUSNUMERO + 8)
   ENOTSOCK        = Errno::ENOTSOCK::Errno rescue (HAUSNUMERO + 9)
-  EINTR           = Errno::EINTR::Errno rescue (HAUSNUMERO + 10)
+  EMSGSIZE        = Errno::EMSGSIZE::Errno rescue (HAUSNUMERO + 10)
+  EAFNOSUPPORT    = Errno::EAFNOSUPPORT::Errno rescue (HAUSNUMERO + 11)
+  ENETUNREACH     = Errno::ENETUNREACH::Errno rescue (HAUSNUMERO + 12)
+  ECONNABORTED    = Errno::ECONNABORTED::Errno rescue (HAUSNUMERO + 13)
+  ECONNRESET      = Errno::ECONNRESET::Errno rescue (HAUSNUMERO + 14)
+  ENOTCONN        = Errno::ENOTCONN::Errno rescue (HAUSNUMERO + 15)
+  ETIMEDOUT       = Errno::ETIMEDOUT::Errno rescue (HAUSNUMERO + 16)
+  EHOSTUNREACH    = Errno::EHOSTUNREACH::Errno rescue (HAUSNUMERO + 17)
+  ENETRESET       = Errno::ENETRESET::Errno rescue (HAUSNUMERO + 18)
+
+  #  Device Types
+  STREAMER = 1
+  FORWARDER = 2
+  QUEUE = 3
 end # module ZMQ
 
 
@@ -93,11 +109,6 @@ if ZMQ::LibZMQ.version2?
     SocketTypeNameMap[ROUTER] = 'ROUTER'
     SocketTypeNameMap[DEALER] = 'DEALER'
 
-    #  Device Types
-    STREAMER = 1
-    FORWARDER = 2
-    QUEUE = 3
-
     # Socket options
     HWM = 1
     IDENTITY = 5
@@ -107,6 +118,7 @@ if ZMQ::LibZMQ.version2?
 
     # Send/recv options
     NOBLOCK = 1
+    NonBlocking = NOBLOCK
   end
 end # version2?
 
@@ -124,22 +136,48 @@ if ZMQ::LibZMQ.version3?
     SocketTypeNameMap[XPUB] = 'XPUB'
     SocketTypeNameMap[XSUB] = 'XSUB'
 
+    # Context options
+    IO_THREADS     = 1
+    MAX_SOCKETS    = 2
+    IO_THREADS_DFLT = 1
+    MAX_SOCKETS_DFLT = 1024
+
     # Socket options
-    IDENTITY = 5
-    MAXMSGSIZE = 22
-    SNDHWM = 23
-    RCVHWM = 24
+    IDENTITY       = 5
+    MAXMSGSIZE     = 22
+    SNDHWM         = 23
+    RCVHWM         = 24
     MULTICAST_HOPS = 25
-    RCVTIMEO = 27
-    SNDTIMEO = 28
+    IPV4ONLY       = 31
+    LAST_ENDPOINT  = 32
+    ROUTER_BEHAVIOR = 33
+    TCP_KEEPALIVE   = 34
+    TCP_KEEPALIVE_CNT = 35
+    TCP_KEEPALIVE_IDLE = 36
+    TCP_KEEPALIVE_INTVL = 37
+    TCP_ACCEPT_FILTER = 38
+    
+    # Message options
+    MORE = 1
 
     # Send/recv options
-    DONTWAIT = 1
-    SNDLABEL = 4
-
+    DONTWAIT       = 1
+    SNDLABEL       = 4
+    NonBlocking    = DONTWAIT
+
+    # Socket events and monitoring
+    EVENT_CONNECTED     = 1
+    EVENT_CONNECT_DELAYED = 2
+    EVENT_CONNECT_RETRIED = 4
+    EVENT_LISTENING = 8
+    EVENT_BIND_FAILED = 16
+    EVENT_ACCEPTED = 32
+    EVENT_ACCEPT_FAILED = 64
+    EVENT_CLOSED = 128
+    EVENT_CLOSE_FAILED = 256
+    EVENT_DISCONNECTED = 512
 
     # Socket & other errors
     EMFILE = Errno::EMFILE::Errno
-
   end
 end # version3?

data/lib/ffi-rzmq/context.rb

@@ -3,9 +3,9 @@ module ZMQ
 
 
   # Recommended to use the default for +io_threads+
-  # since most programs will not saturate I/O. 
+  # since most programs will not saturate I/O.
   #
-  # The rule of thumb is to make +io_threads+ equal to the number 
+  # The rule of thumb is to make +io_threads+ equal to the number
   # gigabits per second that the application will produce.
   #
   # The +io_threads+ number specifies the size of the thread pool
@@ -41,23 +41,50 @@ module ZMQ
   #
   #
   class Context
-    include ZMQ::Util
 
-    attr_reader :context, :pointer
+    attr_reader :context, :io_threads, :max_sockets
+    alias :pointer :context
 
-    def self.create io_threads = 1
-      new(io_threads) rescue nil
-    end
-    
     # Use the factory method Context#create to make contexts.
     #
-    def initialize io_threads = 1
-      @sockets = []
-      @context = LibZMQ.zmq_init io_threads
-      @pointer = @context
-      error_check 'zmq_init', (@context.nil? || @context.null?) ? -1 : 0
+    if LibZMQ.version2?
+      def self.create io_threads = 1
+        new(io_threads) rescue nil
+      end
+
+      def initialize io_threads = 1
+        @io_threads = io_threads
+        @context = LibZMQ.zmq_init io_threads
+        ZMQ::Util.error_check 'zmq_init', (@context.nil? || @context.null?) ? -1 : 0
+
+        define_finalizer
+      end
+    elsif LibZMQ.version3?
+
+      def self.create(opts = {})
+        new(opts) rescue nil
+      end
 
-      define_finalizer
+      def initialize(opts = {})
+        if opts.respond_to?(:empty?)
+          @io_threads = opts[:io_threads] || IO_THREADS_DFLT
+          @max_sockets = opts[:max_sockets] || MAX_SOCKETS_DFLT
+        else
+          @io_threads = opts || 1
+          @max_sockets = MAX_SOCKETS_DFLT
+        end
+
+        @context = LibZMQ.zmq_ctx_new
+        ZMQ::Util.error_check 'zmq_ctx_new', (@context.nil? || @context.null?) ? -1 : 0
+
+        rc = LibZMQ.zmq_ctx_set(@context, ZMQ::IO_THREADS, @io_threads)
+        ZMQ::Util.error_check 'zmq_ctx_set', rc
+
+        rc = LibZMQ.zmq_ctx_set(@context, ZMQ::MAX_SOCKETS, @max_sockets)
+        ZMQ::Util.error_check 'zmq_ctx_set', rc
+
+        define_finalizer
+      end
     end
 
     # Call to release the context and any remaining data associated
@@ -67,15 +94,27 @@ module ZMQ
     #
     # Returns 0 for success, -1 for failure.
     #
-    def terminate
-      unless @context.nil? || @context.null?
-        remove_finalizer
-        rc = LibZMQ.zmq_term @context
-        @context = nil
-        @sockets = nil
-        rc
-      else
-        0
+    if LibZMQ.version2?
+      def terminate
+        unless @context.nil? || @context.null?
+          remove_finalizer
+          rc = LibZMQ.zmq_term @context
+          @context = nil
+          rc
+        else
+          0
+        end
+      end
+    elsif LibZMQ.version3?
+      def terminate
+        unless @context.nil? || @context.null?
+          remove_finalizer
+          rc = LibZMQ.zmq_ctx_destroy(@context)
+          @context = nil
+          rc
+        else
+          0
+        end
       end
     end
 
@@ -102,7 +141,7 @@ module ZMQ
       rescue ContextError => e
         sock = nil
       end
-      
+
       sock
     end
 

data/lib/ffi-rzmq/device.rb

@@ -1,28 +1,28 @@
 module ZMQ
-  if LibZMQ.version2?
-    class Device
-      attr_reader :device
-      
-      def self.create(device_type, frontend, backend)
+
+  class Device
+    attr_reader :device
+
+    def self.create(device_type, frontend, backend)
+      dev = nil
+      begin
+        dev = new(device_type, frontend, backend)
+      rescue ArgumentError
         dev = nil
-        begin
-          dev = new device_type, frontend, backend
-        rescue ArgumentError
-          dev = nil
-        end
-        
-        dev
       end
 
-      def initialize(device_type,frontend,backend)
-        [["frontend", frontend],["backend", backend]].each do |name,socket|
-          unless socket.is_a?(ZMQ::Socket)
-            raise ArgumentError, "Expected a ZMQ::Socket, not a #{socket.class} as the #{name}"
-          end
-        end
+      dev
+    end
 
-        LibZMQ.zmq_device(device_type, frontend.socket, backend.socket)
+    def initialize(device_type, frontend, backend)
+      [["frontend", frontend], ["backend", backend]].each do |name, socket|
+        unless socket.is_a?(ZMQ::Socket)
+          raise ArgumentError, "Expected a ZMQ::Socket, not a #{socket.class} as the #{name}"
+        end
       end
+
+      LibZMQ.zmq_device(device_type, frontend.socket, backend.socket)
     end
   end
+
 end