ffi-rzmq 0.9.0 → 0.9.2

data/examples/v3api/xreqxrep_poll.rb

@@ -0,0 +1,93 @@
+
+require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'ffi-rzmq')
+
+
+def assert(rc)
+  raise "Last API call failed at #{caller(1)}" unless rc >= 0
+end
+
+link = "tcp://127.0.0.1:5555"
+
+
+begin
+  ctx = ZMQ::Context.new
+  s1 = ctx.socket(ZMQ::XREQ)
+  s2 = ctx.socket(ZMQ::XREP)
+rescue ContextError => e
+  STDERR.puts "Failed to allocate context or socket"
+  raise
+end
+
+s1.identity = 'socket1.xreq'
+s2.identity = 'socket2.xrep'
+
+assert(s1.setsockopt(ZMQ::LINGER, 100))
+assert(s2.setsockopt(ZMQ::LINGER, 100))
+
+assert(s1.bind(link))
+assert(s2.connect(link))
+
+poller = ZMQ::Poller.new
+poller.register_readable(s2)
+poller.register_writable(s1)
+
+start_time = Time.now
+@unsent = true
+
+until @done do
+  assert(poller.poll_nonblock)
+
+  # send the message after 5 seconds
+  if Time.now - start_time > 5 && @unsent
+    puts "sending payload nonblocking"
+
+    5.times do |i|
+      payload = "#{ i.to_s * 40 }"
+      assert(s1.send_string(payload, ZMQ::DONTWAIT))
+    end
+    @unsent = false
+  end
+
+  # check for messages after 1 second
+  if Time.now - start_time > 1
+    poller.readables.each do |sock|
+
+      if sock.identity =~ /xrep/
+        routing_info = ''
+        assert(sock.recv_string(routing_info, ZMQ::DONTWAIT))
+        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))
+
+        # skip to the next iteration if received_msg is nil; that means we got an EAGAIN
+        next unless received_msg
+        puts "message received [#{received_msg}] on socket.identity [#{sock.identity}]"
+      end
+
+      while sock.more_parts? do
+        received_msg = ''
+        assert(sock.recv_string(received_msg, ZMQ::DONTWAIT))
+
+        puts "message received [#{received_msg}]"
+      end
+
+      puts "kick back a reply"
+      assert(sock.send_string(routing_info, ZMQ::SNDMORE | ZMQ::DONTWAIT)) 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}"
+      assert(sock.send_string(reply))
+      @done = true
+      poller.register_readable(s1)
+    end
+  end
+end
+
+puts "executed in [#{Time.now - start_time}] seconds"
+
+assert(s1.close)
+assert(s2.close)
+
+ctx.terminate

data/ffi-rzmq.gemspec

@@ -1,36 +1,27 @@
 # -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "ffi-rzmq/version"
 
 Gem::Specification.new do |s|
-  s.name = %q{ffi-rzmq}
-  s.version = "0.9.0"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Chuck Remes"]
-  s.date = %q{2011-09-14}
+  s.name        = "ffi-rzmq"
+  s.version     = ZMQ::VERSION
+  s.authors     = ["Chuck Remes"]
+  s.email       = ["cremes@mac.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:
 MRI 1.9.x, Rubinius and JRuby.}
-  s.email = %q{cremes@mac.com}
-  s.extra_rdoc_files = ["AUTHORS.txt", "History.txt", "README.rdoc", "examples/README.rdoc", "version.txt"]
-  s.files = [".bnsignore", "History.txt", "README.rdoc", "Rakefile", "examples/README.rdoc", "examples/v2api/local_lat.rb", "examples/v2api/local_lat_poll.rb", "examples/v2api/local_throughput.rb", "examples/v2api/publish_subscribe.rb", "examples/v2api/remote_lat.rb", "examples/v2api/remote_throughput.rb", "examples/v2api/reqrep_poll.rb", "examples/v2api/request_response.rb", "examples/v2api/throughput_measurement.rb", "examples/v3api/local_lat.rb", "examples/v3api/local_lat_poll.rb", "examples/v3api/local_throughput.rb", "examples/v3api/publish_subscribe.rb", "examples/v3api/remote_lat.rb", "examples/v3api/remote_throughput.rb", "examples/v3api/reqrep_poll.rb", "examples/v3api/request_response.rb", "examples/v3api/throughput_measurement.rb", "ext/README", "ffi-rzmq.gemspec", "lib/ffi-rzmq.rb", "lib/ffi-rzmq/constants.rb", "lib/ffi-rzmq/context.rb", "lib/ffi-rzmq/device.rb", "lib/ffi-rzmq/exceptions.rb", "lib/ffi-rzmq/libc.rb", "lib/ffi-rzmq/libzmq.rb", "lib/ffi-rzmq/message.rb", "lib/ffi-rzmq/poll.rb", "lib/ffi-rzmq/poll_items.rb", "lib/ffi-rzmq/socket.rb", "lib/ffi-rzmq/util.rb", "spec/context_spec.rb", "spec/device_spec.rb", "spec/message_spec.rb", "spec/multipart_spec.rb", "spec/nonblocking_recv_spec.rb", "spec/pushpull_spec.rb", "spec/reqrep_spec.rb", "spec/socket_spec.rb", "spec/spec_helper.rb", "version.txt"]
-  s.homepage = %q{http://github.com/chuckremes/ffi-rzmq}
-  s.rdoc_options = ["--main", "README.rdoc"]
-  s.require_paths = ["lib"]
-  s.rubyforge_project = %q{ffi-rzmq}
-  s.rubygems_version = %q{1.3.7}
-  s.summary = %q{This gem wraps the ZeroMQ (0mq) networking library using Ruby FFI (foreign function interface).}
 
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
+  s.rubyforge_project = "ffi-rzmq"
+
+  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"]
 
-    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.add_runtime_dependency "ffi", [">= 1.0.9"]
+  s.add_development_dependency "rspec", ["~> 2.6"]
+  s.add_development_dependency "rake"
 end

data/lib/ffi-rzmq/constants.rb

@@ -82,7 +82,7 @@ module ZMQ
 end # module ZMQ
 
 
-if LibZMQ.version2?
+if ZMQ::LibZMQ.version2?
   module ZMQ
     # Socket types
     UPSTREAM = PULL
@@ -111,13 +111,13 @@ if LibZMQ.version2?
 end # version2?
 
 
-if LibZMQ.version3?
+if ZMQ::LibZMQ.version3?
   module ZMQ
     # Socket types
     XPUB = 9
     XSUB = 10
-    ROUTER = 11
-    DEALER = 12
+    DEALER = XREQ
+    ROUTER = XREP
 
     SocketTypeNameMap[ROUTER] = 'ROUTER'
     SocketTypeNameMap[DEALER] = 'DEALER'
@@ -132,7 +132,6 @@ if LibZMQ.version3?
     MULTICAST_HOPS = 25
     RCVTIMEO = 27
     SNDTIMEO = 28
-    RCVLABEL = 29
 
     # Send/recv options
     DONTWAIT = 1
@@ -144,35 +143,3 @@ if LibZMQ.version3?
 
   end
 end # version3?
-
-
-if LibZMQ.version4?
-  module ZMQ
-    # Socket types
-    XPUB = 9
-    XSUB = 10
-    ROUTER = 13
-
-    SocketTypeNameMap[ROUTER] = 'ROUTER'
-    SocketTypeNameMap[XPUB] = 'XPUB'
-    SocketTypeNameMap[XSUB] = 'XSUB'
-
-    # Socket options
-    MAXMSGSIZE = 22
-    SNDHWM = 23
-    RCVHWM = 24
-    MULTICAST_HOPS = 25
-    RCVTIMEO = 27
-    SNDTIMEO = 28
-    RCVLABEL = 29
-
-    # Send/recv options
-    DONTWAIT = 1
-    SNDLABEL = 4
-
-
-    # Socket & other errors
-    EMFILE = Errno::EMFILE::Errno
-
-  end
-end # version4?

data/lib/ffi-rzmq/libzmq.rb

@@ -1,188 +1,201 @@
+module ZMQ
 
-# Wraps the libzmq library and attaches to the functions that are
-# common across the 2.x, 3.x and 4.x APIs.
-#
-module LibZMQ
-  extend FFI::Library
-
-  # bias the library discovery to a path inside the gem first, then
-  # to the usual system paths
-  inside_gem = File.join(File.dirname(__FILE__), '..', '..', 'ext')
-  ZMQ_LIB_PATHS = [
-    inside_gem, '/usr/local/lib', '/opt/local/lib', '/usr/local/homebrew/lib', '/usr/lib64'
-    ].map{|path| "#{path}/libzmq.#{FFI::Platform::LIBSUFFIX}"}
-  ffi_lib(ZMQ_LIB_PATHS + %w{libzmq})
+  # Wraps the libzmq library and attaches to the functions that are
+  # common across the 2.x, 3.x and 4.x APIs.
+  #
+  module LibZMQ
+    extend FFI::Library
+
+    begin
+      # bias the library discovery to a path inside the gem first, then
+      # to the usual system paths
+      inside_gem = File.join(File.dirname(__FILE__), '..', '..', 'ext')
+      ZMQ_LIB_PATHS = [
+      inside_gem, '/usr/local/lib', '/opt/local/lib', '/usr/local/homebrew/lib', '/usr/lib64'
+      ].map{|path| "#{path}/libzmq.#{FFI::Platform::LIBSUFFIX}"}
+      ffi_lib(ZMQ_LIB_PATHS + %w{libzmq})
+    rescue LoadError
+      STDERR.puts "Unable to load this gem. The libzmq library (or DLL) could not be found."
+      STDERR.puts "If this is a Windows platform, make sure libzmq.dll is on the PATH."
+      STDERR.puts "For non-Windows platforms, make sure libzmq is located in this search path:"
+      STDERR.puts ZMQ_LIB_PATHS.inspect
+      exit 255
+    end
 
-  # Size_t not working properly on Windows
-  find_type(:size_t) rescue typedef(:ulong, :size_t)
+    # Size_t not working properly on Windows
+    find_type(:size_t) rescue typedef(:ulong, :size_t)
+
+    # Context and misc api
+    #
+    # @blocking = true is a hint to FFI that the following (and only the following)
+    # function may block, therefore it should release the GIL before calling it.
+    # This can aid in situations where the function call will/may block and another
+    # thread within the lib may try to call back into the ruby runtime. Failure to
+    # release the GIL will result in a hang; the hint *may* allow things to run
+    # smoothly for Ruby runtimes hampered by a GIL.
+    #
+    # This is really only honored by the MRI implementation but it *is* necessary
+    # otherwise the runtime hangs (and requires a kill -9 to terminate)
+    #
+    @blocking = true
+    attach_function :zmq_init, [:int], :pointer
+    @blocking = true
+    attach_function :zmq_socket, [:pointer, :int], :pointer
+    @blocking = true
+    attach_function :zmq_term, [:pointer], :int
+    @blocking = true
+    attach_function :zmq_errno, [], :int
+    @blocking = true
+    attach_function :zmq_strerror, [:int], :pointer
+    @blocking = true
+    attach_function :zmq_version, [:pointer, :pointer, :pointer], :void
+
+    def self.version
+      unless @version
+        major = FFI::MemoryPointer.new :int
+        minor = FFI::MemoryPointer.new :int
+        patch = FFI::MemoryPointer.new :int
+        LibZMQ.zmq_version major, minor, patch
+        @version = {:major => major.read_int, :minor => minor.read_int, :patch => patch.read_int}
+      end
 
-  # Context and misc api
-  #
-  # @blocking = true is a hint to FFI that the following (and only the following)
-  # function may block, therefore it should release the GIL before calling it.
-  # This can aid in situations where the function call will/may block and another
-  # thread within the lib may try to call back into the ruby runtime. Failure to
-  # release the GIL will result in a hang; the hint *may* allow things to run
-  # smoothly for Ruby runtimes hampered by a GIL.
-  #
-  # This is really only honored by the MRI implementation but it *is* necessary
-  # otherwise the runtime hangs (and requires a kill -9 to terminate)
-  #
-  @blocking = true
-  attach_function :zmq_init, [:int], :pointer
-  @blocking = true
-  attach_function :zmq_socket, [:pointer, :int], :pointer
-  @blocking = true
-  attach_function :zmq_term, [:pointer], :int
-  @blocking = true
-  attach_function :zmq_errno, [], :int
-  @blocking = true
-  attach_function :zmq_strerror, [:int], :pointer
-  @blocking = true
-  attach_function :zmq_version, [:pointer, :pointer, :pointer], :void
-
-  def self.version
-    unless @version
-      major = FFI::MemoryPointer.new :int
-      minor = FFI::MemoryPointer.new :int
-      patch = FFI::MemoryPointer.new :int
-      LibZMQ.zmq_version major, minor, patch
-      @version = {:major => major.read_int, :minor => minor.read_int, :patch => patch.read_int}
+      @version
     end
 
-    @version
-  end
+    def self.version2?() version[:major] == 2 && version[:minor] >= 1  end
 
-  def self.version2?() version[:major] == 2 && version[:minor] >= 1  end
+    def self.version3?() version[:major] == 3 && version[:minor] >= 1 end
 
-  def self.version3?() version[:major] == 3 end
+    def self.version4?() version[:major] == 4 end
 
-  def self.version4?() version[:major] == 4 end
 
+    # Message api
+    @blocking = true
+    attach_function :zmq_msg_init, [:pointer], :int
+    @blocking = true
+    attach_function :zmq_msg_init_size, [:pointer, :size_t], :int
+    @blocking = true
+    attach_function :zmq_msg_init_data, [:pointer, :pointer, :size_t, :pointer, :pointer], :int
+    @blocking = true
+    attach_function :zmq_msg_close, [:pointer], :int
+    @blocking = true
+    attach_function :zmq_msg_data, [:pointer], :pointer
+    @blocking = true
+    attach_function :zmq_msg_size, [:pointer], :size_t
+    @blocking = true
+    attach_function :zmq_msg_copy, [:pointer, :pointer], :int
+    @blocking = true
+    attach_function :zmq_msg_move, [:pointer, :pointer], :int
 
-  # Message api
-  @blocking = true
-  attach_function :zmq_msg_init, [:pointer], :int
-  @blocking = true
-  attach_function :zmq_msg_init_size, [:pointer, :size_t], :int
-  @blocking = true
-  attach_function :zmq_msg_init_data, [:pointer, :pointer, :size_t, :pointer, :pointer], :int
-  @blocking = true
-  attach_function :zmq_msg_close, [:pointer], :int
-  @blocking = true
-  attach_function :zmq_msg_data, [:pointer], :pointer
-  @blocking = true
-  attach_function :zmq_msg_size, [:pointer], :size_t
-  @blocking = true
-  attach_function :zmq_msg_copy, [:pointer, :pointer], :int
-  @blocking = true
-  attach_function :zmq_msg_move, [:pointer, :pointer], :int
+    # Used for casting pointers back to the struct
+    #
+    class Msg < FFI::Struct
+      layout :content,  :pointer,
+      :flags,    :uint8,
+      :vsm_size, :uint8,
+      :vsm_data, [:uint8, 30]
+    end # class Msg
 
-  # Used for casting pointers back to the struct
-  #
-  class Msg < FFI::Struct
-    layout :content,  :pointer,
-    :flags,    :uint8,
-    :vsm_size, :uint8,
-    :vsm_data, [:uint8, 30]
-  end # class Msg
-
-  # Socket api
-  @blocking = true
-  attach_function :zmq_setsockopt, [:pointer, :int, :pointer, :int], :int
-  @blocking = true
-  attach_function :zmq_bind, [:pointer, :string], :int
-  @blocking = true
-  attach_function :zmq_connect, [:pointer, :string], :int
-  @blocking = true
-  attach_function :zmq_close, [:pointer], :int
-
-  # Poll api
-  @blocking = true
-  attach_function :zmq_poll, [:pointer, :int, :long], :int
-
-  module PollItemLayout
-    def self.included(base)
-      base.class_eval do
-        layout :socket,  :pointer,
-        :fd,    :int,
-        :events, :short,
-        :revents, :short
-      end
-    end
-  end # module PollItemLayout
+    # Socket api
+    @blocking = true
+    attach_function :zmq_setsockopt, [:pointer, :int, :pointer, :int], :int
+    @blocking = true
+    attach_function :zmq_bind, [:pointer, :string], :int
+    @blocking = true
+    attach_function :zmq_connect, [:pointer, :string], :int
+    @blocking = true
+    attach_function :zmq_close, [:pointer], :int
 
-  class PollItem < FFI::Struct
-    include PollItemLayout
+    # Poll api
+    @blocking = true
+    attach_function :zmq_poll, [:pointer, :int, :long], :int
+
+    module PollItemLayout
+      def self.included(base)
+        base.class_eval do
+          layout :socket,  :pointer,
+          :fd,    :int,
+          :events, :short,
+          :revents, :short
+        end
+      end
+    end # module PollItemLayout
 
-    def socket() self[:socket]; end
+    class PollItem < FFI::Struct
+      include PollItemLayout
 
-    def readable?
-      (self[:revents] & ZMQ::POLLIN) > 0
-    end
+      def socket() self[:socket]; end
+      
+      def fd() self[:fd]; end
 
-    def writable?
-      (self[:revents] & ZMQ::POLLOUT) > 0
-    end
+      def readable?
+        (self[:revents] & ZMQ::POLLIN) > 0
+      end
 
-    def both_accessible?
-      readable? && writable?
-    end
+      def writable?
+        (self[:revents] & ZMQ::POLLOUT) > 0
+      end
 
-    def inspect
-      "socket [#{socket}], fd [#{self[:fd]}], events [#{self[:events]}], revents [#{self[:revents]}]"
-    end
+      def both_accessible?
+        readable? && writable?
+      end
 
-    def to_s; inspect; end
-  end # class PollItem
+      def inspect
+        "socket [#{socket}], fd [#{fd}], events [#{self[:events]}], revents [#{self[:revents]}]"
+      end
 
-end
+      def to_s; inspect; end
+    end # class PollItem
 
+  end
 
-# Attaches to those functions specific to the 2.x API
-#
-if LibZMQ.version2?
 
-  module LibZMQ
-    # Socket api
-    @blocking = true
-    attach_function :zmq_getsockopt, [:pointer, :int, :pointer, :pointer], :int
-    @blocking = true
-    attach_function :zmq_recv, [:pointer, :pointer, :int], :int
-    @blocking = true
-    attach_function :zmq_send, [:pointer, :pointer, :int], :int
-    @blocking = true
-    attach_function :zmq_device, [:int, :pointer, :pointer], :int
+  # Attaches to those functions specific to the 2.x API
+  #
+  if LibZMQ.version2?
+
+    module LibZMQ
+      # Socket api
+      @blocking = true
+      attach_function :zmq_getsockopt, [:pointer, :int, :pointer, :pointer], :int
+      @blocking = true
+      attach_function :zmq_recv, [:pointer, :pointer, :int], :int
+      @blocking = true
+      attach_function :zmq_send, [:pointer, :pointer, :int], :int
+      @blocking = true
+      attach_function :zmq_device, [:int, :pointer, :pointer], :int
+    end
   end
-end
 
 
-# Attaches to those functions specific to the 3.x API
-#
-if LibZMQ.version3? || LibZMQ.version4?
+  # Attaches to those functions specific to the 3.x API
+  #
+  if LibZMQ.version3?
+
+    module LibZMQ
+      # Socket api
+      @blocking = true
+      attach_function :zmq_getsockopt, [:pointer, :int, :pointer, :pointer], :int
+      @blocking = true
+      attach_function :zmq_recvmsg, [:pointer, :pointer, :int], :int
+      @blocking = true
+      attach_function :zmq_recv, [:pointer, :pointer, :size_t, :int], :int
+      @blocking = true
+      attach_function :zmq_sendmsg, [:pointer, :pointer, :int], :int
+      @blocking = true
+      attach_function :zmq_send, [:pointer, :pointer, :size_t, :int], :int
+    end
+  end
 
-  module LibZMQ
-    # Socket api
-    @blocking = true
-    attach_function :zmq_getsockopt, [:pointer, :int, :pointer, :pointer], :int
-    @blocking = true
-    attach_function :zmq_recvmsg, [:pointer, :pointer, :int], :int
-    @blocking = true
-    attach_function :zmq_recv, [:pointer, :pointer, :size_t, :int], :int
-    @blocking = true
-    attach_function :zmq_sendmsg, [:pointer, :pointer, :int], :int
-    @blocking = true
-    attach_function :zmq_send, [:pointer, :pointer, :size_t, :int], :int
+
+  # Sanity check; print an error and exit if we are trying to load an unsupported
+  # version of libzmq.
+  #
+  unless LibZMQ.version2? || LibZMQ.version3?
+    hash = LibZMQ.version
+    version = "#{hash[:major]}.#{hash[:minor]}.#{hash[:patch]}"
+    STDERR.puts "Unable to load this gem. The libzmq version #{version} is incompatible with ffi-rzmq."
+    exit 255
   end
-end
-
-
-# Sanity check; print an error and exit if we are trying to load an unsupported
-# version of libzmq.
-#
-unless LibZMQ.version2? || LibZMQ.version3? || LibZMQ.version4?
-  hash = LibZMQ.version
-  version = "#{hash[:major]}.#{hash[:minor]}.#{hash[:patch]}"
-  STDERR.puts "Unable to load this gem. The libzmq version #{version} is incompatible with ffi-rzmq."
-  exit 255
-end
+
+end # module ZMQ