ffi-rzmq 0.5.0

data/examples/remote_lat_zerocopy.rb

@@ -0,0 +1,35 @@
+require 'rubygems'
+require 'ffi-rzmq'
+
+if ARGV.length < 3
+  puts "usage: remote_lat <connect-to> <message-size> <roundtrip-count>"
+  exit
+end
+
+connect_to = ARGV[0]
+message_size = ARGV[1].to_i
+roundtrip_count = ARGV[2].to_i
+
+ctx = ZMQ::Context.new 1
+s = ctx.socket ZMQ::REQ
+s.connect connect_to
+
+msg = ZMQ::Message.new "#{'3'*message_size}"
+
+start_time = Time.now
+
+roundtrip_count.times do
+  s.send msg, 0
+  result = s.recv msg, 0
+  raise "Message size doesn't match, expected [#{message_size}] but received [#{msg.size}]" if message_size != msg.size
+end
+
+end_time = Time.now
+elapsed_secs = (end_time.to_f - start_time.to_f)
+elapsed_usecs = elapsed_secs * 1000000
+latency = elapsed_usecs / roundtrip_count / 2
+
+puts "message size: %i [B]" % message_size
+puts "roundtrip count: %i" % roundtrip_count
+puts "throughput (msgs/s): %i" % (roundtrip_count / elapsed_secs)
+puts "mean latency: %.3f [us]" % latency

data/examples/reqrep_poll.rb

@@ -0,0 +1,49 @@
+require 'rubygems'
+require 'ffi-rzmq'
+
+
+link = "tcp://127.0.0.1:5555"
+
+ctx = ZMQ::Context.new 1
+s1 = ctx.socket ZMQ::REQ
+s2 = ctx.socket ZMQ::REP
+
+s1.connect link
+s2.bind link
+
+poller = ZMQ::Poller.new
+poller.register_readable s2
+poller.register_writable s1
+
+start_time = Time.now
+@unsent = true
+
+until @done do
+  begin
+    poller.poll_nonblock
+  rescue ZMQ::PollError => e
+    puts "efault? [#{e.efault?}]"
+    raise
+  end
+
+  # send the message after 5 seconds
+  if Time.now - start_time > 5 && @unsent
+    payload = "#{ '3' * 1024 }"
+
+    puts "sending payload nonblocking"
+    s1.send_string payload, ZMQ::NOBLOCK
+    @unsent = false
+  end
+
+  # check for messages after 1 second
+  if Time.now - start_time > 1
+    poller.readables.each do |sock|
+      received_msg = sock.recv_string ZMQ::NOBLOCK
+
+      puts "message received [#{received_msg}]"
+      @done = true
+    end
+  end
+end
+
+puts "executed in [#{Time.now - start_time}] seconds"

data/examples/request_response.rb

@@ -0,0 +1,23 @@
+require 'rubygems'
+require 'ffi-rzmq'
+
+
+link = "tcp://127.0.0.1:5555"
+
+ctx = ZMQ::Context.new 1
+s1 = ctx.socket ZMQ::REQ
+s2 = ctx.socket ZMQ::REP
+
+s2.bind link
+s1.connect link
+
+payload = "#{ '3' * 2048 }"
+sent_msg = ZMQ::Message.new payload
+received_msg = ZMQ::Message.new
+
+s1.send sent_msg
+s2.recv received_msg
+
+result = payload == received_msg.copy_out_string ? "Request received" : "Received wrong payload"
+
+p result

data/ffi-rzmq.gemspec

@@ -0,0 +1,43 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{ffi-rzmq}
+  s.version = "0.5.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Chuck Remes"]
+  s.date = %q{2010-06-06}
+  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. Right now that means
+MRI 1.8.7, 1.9.1 and JRuby.
+
+The impetus behind this library was to provide support for ZeroMQ in
+JRuby which has native threads. Unlike MRI, MacRuby, IronRuby and
+Rubinius which all have a GIL, JRuby allows for threaded access to ruby
+code from outside extensions. ZeroMQ is heavily threaded, so until the
+other runtimes remove their GIL, JRuby will likely be the best
+environment to run this library.}
+  s.email = %q{cremes@mac.com}
+  s.extra_rdoc_files = ["History.txt", "README.rdoc", "version.txt"]
+  s.files = ["History.txt", "README.rdoc", "Rakefile", "examples/local_lat.rb", "examples/local_lat_zerocopy.rb", "examples/publish_subscribe.rb", "examples/remote_lat.rb", "examples/remote_lat_zerocopy.rb", "examples/reqrep_poll.rb", "examples/request_response.rb", "ffi-rzmq.gemspec", "lib/ffi-rzmq.rb", "lib/ffi-rzmq/context.rb", "lib/ffi-rzmq/exceptions.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/wrapper.rb", "lib/ffi-rzmq/zmq.rb", "spec/context_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.6}
+  s.summary = %q{This gem wraps the ZeroMQ networking library using the ruby FFI (foreign function interface)}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<bones>, [">= 3.4.3"])
+    else
+      s.add_dependency(%q<bones>, [">= 3.4.3"])
+    end
+  else
+    s.add_dependency(%q<bones>, [">= 3.4.3"])
+  end
+end

data/lib/ffi-rzmq.rb

@@ -0,0 +1,71 @@
+
+module ZMQ
+
+  # :stopdoc:
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  # :startdoc:
+
+  # Returns the version string for the library.
+  #
+  def self.version
+    @version ||= File.read(path('version.txt')).strip
+  end
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args, &block )
+    rv =  args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+    if block
+      begin
+        $LOAD_PATH.unshift LIBPATH
+        rv = block.call
+      ensure
+        $LOAD_PATH.shift
+      end
+    end
+    return rv
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  #
+  def self.path( *args, &block )
+    rv = args.empty? ? PATH : ::File.join(PATH, args.flatten)
+    if block
+      begin
+        $LOAD_PATH.unshift PATH
+        rv = block.call
+      ensure
+        $LOAD_PATH.shift
+      end
+    end
+    return rv
+  end
+
+  # Utility method used to require all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  #
+  def self.require_all_libs_relative_to( fname, dir = nil )
+    dir ||= ::File.basename(fname, '.*')
+    search_me = ::File.expand_path(
+    ::File.join(::File.dirname(fname), dir, '**', '*.rb'))
+
+    Dir.glob(search_me).sort.each {|rb| require rb}
+  end
+
+end  # module ZMQ
+
+# some code is conditionalized based upon what ruby engine we are
+# executing
+RBX = RUBY_ENGINE =~ /rbx/ ? true : false
+
+# the order of files is important
+%w(wrapper zmq exceptions context message socket poll_items poll).each do |file|
+  require ZMQ.libpath(['ffi-rzmq', file])
+end

data/lib/ffi-rzmq/context.rb

@@ -0,0 +1,99 @@
+
+module ZMQ
+
+  ZMQ_INIT_STR = 'zmq_init'.freeze
+  ZMQ_TERM_STR = 'zmq_term'.freeze
+  ZMQ_SOCKET_STR = 'zmq_socket'.freeze unless defined? ZMQ_SOCKET_STR
+
+
+  class Context
+    include ZMQ::Util
+
+    attr_reader :context, :pointer
+
+    # Recommended to just pass 1 for +io_threads+
+    # since most programs are not heavily threaded. The rule of thumb
+    # is to make +io_threads+ equal to the number of application
+    # threads that will be accessing 0mq sockets within this context.
+    # The +io_threads+ number specifies the size of the thread pool
+    # allocated by 0mq for processing incoming/outgoing messages.
+    #
+    # Returns a context object. It's necessary for passing to the
+    # #Socket constructor when allocating new sockets. All sockets
+    # live within a context. Sockets in one context may not be accessed
+    # from another context; doing so raises an exception.
+    #
+    # To connect sockets between contexts, use +inproc+ or +ipc+
+    # transport and set up a 0mq socket between them.
+    #
+    # May raise a #ContextError.
+    #
+    def initialize io_threads
+      @sockets ||= []
+      @context = LibZMQ.zmq_init io_threads
+      @pointer = @context
+      error_check ZMQ_INIT_STR, @context.null? ? 1 : 0
+
+      define_finalizer
+    end
+
+    # Call to release the context and any remaining data associated
+    # with past sockets. This will close any sockets that remain
+    # open; further calls to those sockets will raise failure
+    # exceptions.
+    #
+    # Returns nil.
+    #
+    # May raise a #ContextError.
+    #
+    def terminate
+      unless @context.nil? || @context.null?
+        result_code = LibZMQ.zmq_term @context
+        error_check ZMQ_TERM_STR, result_code
+        @context = nil
+        @sockets = nil
+        remove_finalizer
+      end
+      nil
+    end
+
+    # Short-cut to allocate a socket for a specific context.
+    #
+    # Takes several +type+ values:
+    #   #ZMQ::REQ
+    #   #ZMQ::REP
+    #   #ZMQ::PUB
+    #   #ZMQ::SUB
+    #   #ZMQ::PAIR
+    #   #ZMQ::UPSTREAM
+    #   #ZMQ::DOWNSTREAM
+    #   #ZMQ::XREQ
+    #   #ZMQ::XREP
+    #
+    # Returns a #ZMQ::Socket.
+    #
+    # May raise a #ContextError or #SocketError.
+    #
+    def socket type
+      sock = Socket.new @context, type
+      error_check ZMQ_SOCKET_STR, sock.nil? ? 1 : 0
+      sock
+    end
+
+
+    private
+
+    def define_finalizer
+      ObjectSpace.define_finalizer(self, self.class.close(@context))
+    end
+
+    def remove_finalizer
+      ObjectSpace.undefine_finalizer self
+    end
+
+    def self.close context
+      Proc.new { LibZMQ.zmq_term context unless context.null? }
+    end
+  end
+
+end # module ZMQ

data/lib/ffi-rzmq/exceptions.rb

@@ -0,0 +1,145 @@
+
+module ZMQ
+
+  class ZeroMQError < StandardError
+    attr_reader :source, :result_code, :error_code, :message
+
+    def initialize source, result_code, error_code, message
+      @source = source
+      @result_code = result_code
+      @error_code = error_code
+      @message = message
+      super message
+    end
+  end # call ZeroMQError
+
+
+  class ContextError < ZeroMQError
+    # True when the exception was raised due to the library
+    # returning EINVAL.
+    #
+    # Occurs when he number of app_threads requested is less
+    # than one, or the number of io_threads requested is
+    # negative.
+    #
+    def einval?() EINVAL == @error_code; end
+
+    # True when the exception was raised due to the library
+    # returning ETERM.
+    #
+    # The associated context was terminated.
+    #
+    def eterm?() ETERM == @error_code; end
+
+  end # class ContextError
+
+
+  class PollError < ZeroMQError
+    # True when the exception was raised due to the library
+    # returning EMTHREAD.
+    #
+    # At least one of the members of the items array refers
+    # to a socket belonging to a different application
+    # thread.
+    #
+    def efault?() EFAULT == @error_code; end
+
+  end # class PollError
+
+
+  class SocketError < ZeroMQError
+    # True when the exception was raised due to the library
+    # returning EMTHREAD.
+    #
+    # Occurs for #send and #recv operations.
+    # * When calling #send, non-blocking mode was requested
+    # and the message cannot be queued at the moment.
+    # * When calling #recv, non-blocking mode was requested
+    # and no messages are available at the moment.
+    #
+    def egain?() EAGAIN == @error_code; end
+
+    # True when the exception was raised due to the library
+    # returning ENOCOMPATPROTO.
+    #
+    # The requested transport protocol is not compatible
+    # with the socket type.
+    #
+    def enocompatproto?() ENOCOMPATPROTO == @error_code; end
+
+    # True when the exception was raised due to the library
+    # returning EPROTONOSUPPORT.
+    #
+    # The requested transport protocol is not supported.
+    #
+    def eprotonosupport?() EPROTONOSUPPORT == @error_code; end
+
+    # True when the exception was raised due to the library
+    # returning EADDRINUSE.
+    #
+    # The given address is already in use.
+    #
+    def eaddrinuse?() EADDRINUSE == @error_code; end
+
+    # True when the exception was raised due to the library
+    # returning EADDRNOTAVAIL.
+    #
+    # A nonexistent interface was requested or the
+    # requested address was not local.
+    #
+    def eaddrnotavail?() EADDRNOTAVAIL == @error_code; end
+
+    # True when the exception was raised due to the library
+    # returning EMTHREAD.
+    #
+    # Occurs under 2 conditions.
+    # * When creating a new #Socket, the requested socket
+    # type is invalid.
+    #
+    # * When setting socket options with #setsockopt, the
+    # requested option +option_name+ is unknown, or the
+    # requested +option_len+ or +option_value+ is invalid.
+    #
+    def einval?() EINVAL == @error_code; end
+
+    # True when the exception was raised due to the library
+    # returning EMTHREAD.
+    #
+    # The send or recv operation cannot be performed on this
+    # socket at the moment due to the socket not being in
+    # the appropriate state. This error may occur with socket
+    # types that switch between several states, such as ZMQ::REP.
+    #
+    def efsm?() EFSM == @error_code; end
+
+    # True when the exception was raised due to the library
+    # returning ENOTSUP.
+    #
+    # The send or recv operation is not supported by this socket
+    # type.
+    #
+    def enotsup?() super; end
+
+    # True when the exception was raised due to the library
+    # returning EMTHREAD.
+    #
+    # The number of application threads using sockets within
+    # this context has been exceeded. See the +app_threads+
+    # parameter of #Context.
+    #
+    def emthread?() EMTHREAD == @error_code; end
+
+  end # class SocketError
+
+
+  class MessageError < ZeroMQError
+    # True when the exception was raised due to the library
+    # returning ENOMEM.
+    #
+    # Only ever raised by the #Message class when it fails
+    # to allocate sufficient memory to send a message.
+    #
+    def enomem?() ENOMEM == @error_code; end
+  end
+
+end # module ZMQ