ffi-rzmq 0.8.2 → 0.9.0

data/examples/reqrep_poll.rb

@@ -1,49 +0,0 @@
-require 'rubygems'
-require 'ffi-rzmq'
-
-
-link = "tcp://127.0.0.1:5554"
-
-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

@@ -1,23 +0,0 @@
-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/lib/ffi-rzmq/wrapper.rb

@@ -1,121 +0,0 @@
-require 'ffi' unless RBX # external gem
-
-module LibC
-  extend FFI::Library
-  # figures out the correct libc for each platform including Windows
-  library = ffi_lib(FFI::Library::LIBC).first
-
-  # Size_t not working properly on Windows
-  find_type(:size_t) rescue typedef(:ulong, :size_t)
-
-  # memory allocators
-  attach_function :malloc, [:size_t], :pointer
-  attach_function :free, [:pointer], :void
-  
-  # get a pointer to the free function; used for ZMQ::Message deallocation
-  Free = library.find_symbol('free')
-
-  # memory movers
-  attach_function :memcpy, [:pointer, :pointer, :size_t], :pointer
-end # module LibC
-
-module LibZMQ
-  extend FFI::Library
-  ZMQ_LIB_PATHS = %w{/usr/local/lib /opt/local/lib /usr/local/homebrew/lib}.map{|path| "#{path}/libzmq.#{FFI::Platform::LIBSUFFIX}"}
-  ffi_lib(%w{libzmq} + ZMQ_LIB_PATHS)
-
-  # Size_t not working properly on Windows
-  find_type(:size_t) rescue typedef(:ulong, :size_t)
-
-  # Misc
-  attach_function :zmq_version, [:pointer, :pointer, :pointer], :void
-
-  # Context and misc api
-  attach_function :zmq_init, [:int], :pointer
-  attach_function :zmq_socket, [:pointer, :int], :pointer
-  attach_function :zmq_term, [:pointer], :int
-  attach_function :zmq_errno, [], :int
-  attach_function :zmq_strerror, [:int], :pointer
-
-  # Message api
-  attach_function :zmq_msg_init, [:pointer], :int
-  attach_function :zmq_msg_init_size, [:pointer, :size_t], :int
-  attach_function :zmq_msg_init_data, [:pointer, :pointer, :size_t, :pointer, :pointer], :int
-  attach_function :zmq_msg_close, [:pointer], :int
-  attach_function :zmq_msg_data, [:pointer], :pointer
-  attach_function :zmq_msg_size, [:pointer], :size_t
-  attach_function :zmq_msg_copy, [:pointer, :pointer], :int
-  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
-
-
-  # Socket 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.
-  attach_function :zmq_setsockopt, [:pointer, :int, :pointer, :int], :int
-  attach_function :zmq_getsockopt, [:pointer, :int, :pointer, :pointer], :int
-  attach_function :zmq_bind, [:pointer, :string], :int
-  attach_function :zmq_connect, [:pointer, :string], :int
-  @blocking = true
-  attach_function :zmq_send, [:pointer, :pointer, :int], :int
-  @blocking = true
-  attach_function :zmq_recv, [:pointer, :pointer, :int], :int
-  attach_function :zmq_close, [:pointer], :int
-
-  @blocking = true
-  attach_function :zmq_device, [:int, :pointer, :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
-
-  class PollItem < FFI::Struct
-    include PollItemLayout
-    
-    def socket() self[:socket]; end
-
-    def readable?
-      (self[:revents] & ZMQ::POLLIN) > 0
-    end
-
-    def writable?
-      (self[:revents] & ZMQ::POLLOUT) > 0
-    end
-
-    def both_accessible?
-      readable? && writable?
-    end
-
-    def inspect
-      "socket [#{socket}], fd [#{self[:fd]}], events [#{self[:events]}], revents [#{self[:revents]}]"
-    end
-
-    def to_s; inspect; end
-  end # class PollItem
-
-end # module LibZMQ

data/lib/ffi-rzmq/zmq.rb

@@ -1,198 +0,0 @@
-module ZMQ
-
-  #  Socket types
-  PAIR = 0
-  PUB = 1
-  SUB = 2
-  REQ = 3
-  REP = 4
-  DEALER = XREQ = 5
-  ROUTER = XREP = 6
-  PULL = UPSTREAM = 7
-  PUSH = DOWNSTREAM = 8
-
-  SocketTypeNameMap = {
-    PAIR => "PAIR",
-    PUB => "PUB",
-    SUB => "SUB",
-    REQ => "REQ",
-    REP => "REP",
-    ROUTER => "ROUTER",
-    DEALER => "DEALER",
-    PULL => "PULL",
-    PUSH => "PUSH"
-  }
-
-  #  Socket options
-  HWM = 1
-  SWAP = 3
-  AFFINITY = 4
-  IDENTITY = 5
-  SUBSCRIBE = 6
-  UNSUBSCRIBE = 7
-  RATE = 8
-  RECOVERY_IVL = 9
-  MCAST_LOOP = 10
-  SNDBUF = 11
-  RCVBUF = 12
-  RCVMORE = 13
-  FD = 14
-  EVENTS = 15
-  TYPE = 16
-  LINGER = 17
-  RECONNECT_IVL = 18
-  BACKLOG = 19
-  RECOVERY_IVL_MSEC = 20
-
-  #  Send/recv options
-  NOBLOCK = 1
-  SNDMORE = 2
-
-  #  I/O multiplexing
-
-  POLL = 1
-  POLLIN = 1
-  POLLOUT = 2
-  POLLERR = 4
-
-  #  Socket errors
-  EAGAIN = Errno::EAGAIN::Errno
-  EINVAL = Errno::EINVAL::Errno
-  ENOMEM = Errno::ENOMEM::Errno
-  ENODEV = Errno::ENODEV::Errno
-  EFAULT = Errno::EFAULT::Errno
-
-  #  Device Types
-  STREAMER = 1
-  FORWARDER = 2
-  QUEUE = 3
-
-  # ZMQ errors
-  HAUSNUMERO     = 156384712
-  EMTHREAD       = (HAUSNUMERO + 50)
-  EFSM           = (HAUSNUMERO + 51)
-  ENOCOMPATPROTO = (HAUSNUMERO + 52)
-  ETERM          = (HAUSNUMERO + 53)
-
-  # Rescue unknown constants and use the ZeroMQ defined values
-  # Usually only happens on Windows though some don't resolve on
-  # OSX too (ENOTSUP)
-  ENOTSUP         = Errno::ENOTSUP::Errno rescue (HAUSNUMERO + 1)
-  EPROTONOSUPPORT = Errno::EPROTONOSUPPORT::Errno rescue (HAUSNUMERO + 2)
-  ENOBUFS         = Errno::ENOBUFS::Errno rescue (HAUSNUMERO + 3)
-  ENETDOWN        = Errno::ENETDOWN::Errno rescue (HAUSNUMERO + 4)
-  EADDRINUSE      = Errno::EADDRINUSE::Errno rescue (HAUSNUMERO + 5)
-  EADDRNOTAVAIL   = Errno::EADDRNOTAVAIL::Errno rescue (HAUSNUMERO + 6)
-  ECONNREFUSED    = Errno::ECONNREFUSED::Errno rescue (HAUSNUMERO + 7)
-  EINPROGRESS     = Errno::EINPROGRESS::Errno rescue (HAUSNUMERO + 8)
-
-
-
-  # These methods don't belong to any specific context. They get included
-  # in the #Context, #Socket and #Poller classes.
-  #
-  module Util
-
-    # Returns the +errno+ as set by the libzmq library.
-    #
-    def errno
-      LibZMQ.zmq_errno
-    end
-
-    # Returns a string corresponding to the currently set #errno. These
-    # error strings are defined by libzmq.
-    #
-    def error_string
-      LibZMQ.zmq_strerror(errno).read_string
-    end
-
-    # Returns an array of the form [major, minor, patch] to represent the
-    # version of libzmq.
-    #
-    # Class method! Invoke as:  ZMQ::Util.version
-    #
-    def self.version
-      major = FFI::MemoryPointer.new :int
-      minor = FFI::MemoryPointer.new :int
-      patch = FFI::MemoryPointer.new :int
-      LibZMQ.zmq_version major, minor, patch
-      [major.read_int, minor.read_int, patch.read_int]
-    end
-
-    # Compares the 0mq library API version to a minimal version tuple. Returns
-    # true if it meets the minimum requirement, false otherwise.
-    #
-    # Takes a +tuple+ with 3 elements corresponding to the major, minor and patch
-    # version levels.
-    #
-    # e.g.  Util.minimum_api?([2, 1, 0])
-    #
-    def self.minimum_api? tuple
-      api_version = Util.version
-
-      # call #to_i to convert nil entries to 0 so the comparison is valid
-      result = tuple[0].to_i <= api_version[0] &&
-      tuple[1].to_i <= api_version[1] &&
-      tuple[2].to_i <= api_version[2]
-    end
-
-
-    private
-
-    # :doc:
-    # Called by most library methods to verify there were no errors during
-    # operation. If any are found, raise the appropriate #ZeroMQError.
-    #
-    # When no error is found, this method returns +true+ which is behavior
-    # used internally by #send and #recv.
-    #
-    def error_check source, result_code
-      unless result_code.zero?
-        raise_error source, result_code
-      end
-
-      # used by Socket::send/recv, ignored by others
-      true
-    end
-
-    # :doc:
-    # Only called on sockets in non-blocking mode.
-    #
-    # Checks the #errno and +result_code+ values for a failed non-blocking
-    # send/recv. True only when #errno is EGAIN and +result_code+ is non-zero.
-    #
-    def error_check_nonblock result_code
-      if result_code.zero?
-        true
-      else
-        # need to check result_code again because !eagain? could be true
-        # and we need the result_code test to fail again to give the right result
-        #  !eagain? is true, result_code is -1 => return false
-        #  !eagain? is false, result_code is -1 => return false
-        !eagain? && result_code.zero?
-      end
-    end
-
-    def raise_error source, result_code
-      case source
-      when ZMQ_SEND_STR, ZMQ_RECV_STR, ZMQ_SOCKET_STR, ZMQ_SETSOCKOPT_STR, ZMQ_GETSOCKOPT_STR, ZMQ_BIND_STR, ZMQ_CONNECT_STR, ZMQ_CLOSE_STR
-        raise SocketError.new source, result_code, errno, error_string
-      when ZMQ_INIT_STR, ZMQ_TERM_STR
-        raise ContextError.new source, result_code, errno, error_string
-      when ZMQ_POLL_STR
-        raise PollError.new source, result_code, errno, error_string
-      when ZMQ_MSG_INIT_STR, ZMQ_MSG_INIT_DATA_STR, ZMQ_MSG_COPY_STR, ZMQ_MSG_MOVE_STR
-        raise MessageError.new source, result_code, errno, error_string
-      else
-        raise ZeroMQError.new source, result_code, -1,
-        "Source [#{source}] does not match any zmq_* strings, rc [#{result_code}], errno [#{errno}], error_string [#{error_string}]"
-      end
-    end
-
-    def eagain?
-      EAGAIN == errno
-    end
-
-  end # module Util
-
-end # module ZMQ