ffi-rxs 1.1.0 → 1.2.0

data/lib/ffi-rxs/constants.rb~

@@ -1,100 +0,0 @@
-module XS
-  # Set up all of the constants
-  
-  #  Socket types
-  PAIR = 0
-  PUB = 1
-  SUB = 2
-  REQ = 3
-  REP = 4
-  XREQ = 5
-  XREP = 6
-  PULL = 7
-  PUSH = 8
-  XPUB = 9
-  XSUB = 10
-  DEALER = XREQ
-  ROUTER = XREP
-
-  SocketTypeNameMap = {
-    PAIR => "PAIR",
-    PUB => "PUB",
-    SUB => "SUB",
-    REQ => "REQ",
-    REP => "REP",
-    PULL => "PULL",
-    PUSH => "PUSH",
-    XREQ => "XREQ",
-    XREP => "XREP",
-    ROUTER => "ROUTER",
-    DEALER => "DEALER",
-    XPUB => "XPUB",
-    XSUB => "XSUB"
-  }
-
-  #  Socket options
-  AFFINITY = 4
-  IDENTITY = 5
-  SUBSCRIBE = 6
-  UNSUBSCRIBE = 7
-  RATE = 8
-  RECOVERY_IVL = 9
-  SNDBUF = 11
-  RCVBUF = 12
-  RCVMORE = 13
-  FD = 14
-  EVENTS = 15
-  TYPE = 16
-  LINGER = 17
-  RECONNECT_IVL = 18
-  BACKLOG = 19
-  RECONNECT_IVL_MAX = 21
-  MAXMSGSIZE = 22
-  SNDHWM = 23
-  RCVHWM = 24
-  MULTICAST_HOPS = 25
-  RCVTIMEO = 27
-  SNDTIMEO = 28
-
-  #  Send/recv options
-  DONTWAIT = 1
-  SNDMORE = 2
-  SNDLABEL = 4
-  NonBlocking = DONTWAIT
-
-  #  I/O multiplexing
-
-  POLL = 1
-  POLLIN = 1
-  POLLOUT = 2
-  POLLERR = 4
-
-  #  Socket errors
-  EAGAIN = Errno::EAGAIN::Errno
-  EFAULT = Errno::EFAULT::Errno
-  EINVAL = Errno::EINVAL::Errno
-  EMFILE = Errno::EMFILE::Errno
-  ENOMEM = Errno::ENOMEM::Errno
-  ENODEV = Errno::ENODEV::Errno
-  
-  # XS errors
-  HAUSNUMERO     = 156384712
-  EMTHREAD       = (HAUSNUMERO + 50)
-  EFSM           = (HAUSNUMERO + 51)
-  ENOCOMPATPROTO = (HAUSNUMERO + 52)
-  ETERM          = (HAUSNUMERO + 53)
-
-  # Rescue unknown constants and use the Crossroads 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)
-  ENOTSOCK        = Errno::ENOTSOCK::Errno rescue (HAUSNUMERO + 9)
-  EINTR           = Errno::EINTR::Errno rescue (HAUSNUMERO + 10)
-end # module XS

data/lib/ffi-rxs/context.rb~

@@ -1,155 +0,0 @@
-
-module XS
-
-
-  # Recommended to use the default for +io_threads+
-  # since most programs will not saturate I/O. 
-  #
-  # 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
-  # allocated by 0mq for processing incoming/outgoing messages.
-  #
-  # Returns a context object when allocation succeeds. It's necessary
-  # for passing to the
-  # #Socket constructor when allocating new sockets. All sockets
-  # live within a context.
-  #
-  # Also, Sockets should *only* be accessed from the thread where they
-  # were first created. Do *not* pass sockets between threads; pass
-  # in the context and allocate a new socket per thread. If you must
-  # use threads, then make sure to execute a full memory barrier (e.g.
-  # mutex) as you pass a socket from one thread to the next.
-  #
-  # To connect sockets between contexts, use +inproc+ or +ipc+
-  # transport and set up a Crossroads socket between them. This is also the
-  # recommended technique for allowing sockets to communicate between
-  # threads.
-  #
-  #  context = XS::Context.create
-  #  if context
-  #    socket = context.socket(XS::REQ)
-  #    if socket
-  #      ...
-  #    else
-  #      STDERR.puts "Socket allocation failed"
-  #    end
-  #  else
-  #    STDERR.puts "Context allocation failed"
-  #  end
-  #
-  #
-  class Context
-    include XS::Util
-
-    attr_reader :context, :pointer
-
-    def self.create
-      new() rescue nil
-    end
-    
-    # Use the factory method Context#create to make contexts.
-    #
-    def initialize
-      @sockets = []
-      @context = LibXS.xs_init()
-      @pointer = @context
-      error_check 'xs_init', (@context.nil? || @context.null?) ? -1 : 0
-
-      define_finalizer
-    end
-    
-    # Set options on this context.
-    #
-    # Context options take effect only if set with setctxopt() prior to
-    # creating the first socket in a given context with socket().
-    #
-    # Valid +name+ values that take a numeric +value+ are:
-    #  XS::IO_THREADS
-    #  XS::MAX_SOCKETS
-    #
-    # Returns 0 when the operation completed successfully.
-    # Returns -1 when this operation failed.
-    #
-    # With a -1 return code, the user must check XS.errno to determine the
-    # cause.
-    #
-    #  rc = context.setctxopt(XS::IO_THREADS, 10)
-    #  XS::Util.resultcode_ok?(rc) ? puts("succeeded") : puts("failed")
-    #
-    def setctxopt name, value, length = nil
-      #if (name == XS::IO_THREADS) || (name == XS::MAX_SOCKETS)
-        length = 4
-        pointer = LibC.malloc length
-        pointer.write_int value
-      #end
-
-      rc = LibXS.xs_setctxopt @context, name, pointer, length
-      LibC.free(pointer) unless pointer.nil? || pointer.null?
-      rc
-    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 return -1 to indicate
-    # the operation failed.
-    #
-    # Returns 0 for success, -1 for failure.
-    #
-    def terminate
-      unless @context.nil? || @context.null?
-        remove_finalizer
-        rc = LibXS.xs_term @context
-        @context = nil
-        @sockets = nil
-        rc
-      else
-        0
-      end
-    end
-
-    # Short-cut to allocate a socket for a specific context.
-    #
-    # Takes several +type+ values:
-    #   #XS::REQ
-    #   #XS::REP
-    #   #XS::PUB
-    #   #XS::SUB
-    #   #XS::PAIR
-    #   #XS::PULL
-    #   #XS::PUSH
-    #   #XS::DEALER
-    #   #XS::ROUTER
-    #
-    # Returns a #XS::Socket when the allocation succeeds, nil
-    # if it fails.
-    #
-    def socket type
-      sock = nil
-      begin
-        sock = Socket.new @context, type
-      rescue ContextError => e
-        sock = nil
-      end
-      
-      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 { LibXS.xs_term context unless context.null? }
-    end
-  end
-
-end # module XS

data/lib/ffi-rxs/device.rb~

@@ -1,28 +0,0 @@
-module ZMQ
-  if LibZMQ.version2?
-    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
-        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
-
-        LibZMQ.zmq_device(device_type, frontend.socket, backend.socket)
-      end
-    end
-  end
-end

data/lib/ffi-rxs/exceptions.rb~

@@ -1,47 +0,0 @@
-
-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 = "msg [#{message}], error code [#{error_code}], rc [#{result_code}]"
-      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 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

data/lib/ffi-rxs/libc.rb~

@@ -1,19 +0,0 @@
-
-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

data/lib/ffi-rxs/libxs.rb~

@@ -1,156 +0,0 @@
-module XS
-
-  # Wraps the libxs library and attaches to the API functions
-  #
-  module LibXS
-    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')
-      XS_LIB_PATHS = [
-      inside_gem, '/usr/local/lib', '/opt/local/lib', '/usr/local/homebrew/lib', '/usr/lib64'
-      ].map{|path| "#{path}/libxs.#{FFI::Platform::LIBSUFFIX}"}
-      ffi_lib(XS_LIB_PATHS + %w{libxs})
-    rescue LoadError
-      STDERR.puts "Unable to load this gem. The libxs library (or DLL) could not be found."
-      STDERR.puts "If this is a Windows platform, make sure libxs.dll is on the PATH."
-      STDERR.puts "For non-Windows platforms, make sure libxs is located in this search path:"
-      STDERR.puts XS_LIB_PATHS.inspect
-      exit 255
-    end
-
-    # 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 :xs_errno, [], :int
-    @blocking = true
-    attach_function :xs_init, [:int], :pointer
-    @blocking = true
-    attach_function :xs_setctxopt, [:pointer, :int, :pointer, :int], :int
-    @blocking = true
-    attach_function :xs_socket, [:pointer, :int], :pointer
-    @blocking = true
-    attach_function :xs_strerror, [:int], :pointer
-    @blocking = true
-    attach_function :xs_term, [:pointer], :int
-    @blocking = true
-    attach_function :xs_version, [:pointer, :pointer, :pointer], :void
-
-    def self.version
-      if @version.nil?
-        major = FFI::MemoryPointer.new :int
-        minor = FFI::MemoryPointer.new :int
-        patch = FFI::MemoryPointer.new :int
-        LibXS.xs_version major, minor, patch
-        @version = {:major => major.read_int, :minor => minor.read_int, :patch => patch.read_int}
-      end
-
-      @version
-    end
-
-    # Message api
-    @blocking = true
-    attach_function :xs_msg_close, [:pointer], :int
-    @blocking = true
-    attach_function :xs_msg_copy, [:pointer, :pointer], :int
-    @blocking = true
-    attach_function :xs_msg_data, [:pointer], :pointer
-    @blocking = true
-    attach_function :xs_msg_init, [:pointer], :int
-    @blocking = true
-    attach_function :xs_msg_init_size, [:pointer, :size_t], :int
-    @blocking = true
-    attach_function :xs_msg_init_data, [:pointer, :pointer, :size_t, :pointer, :pointer], :int
-    @blocking = true
-    attach_function :xs_msg_move, [:pointer, :pointer], :int
-    @blocking = true
-    attach_function :xs_msg_size, [:pointer], :size_t
-    
-    # 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 :xs_bind, [:pointer, :string], :int
-    @blocking = true
-    attach_function :xs_connect, [:pointer, :string], :int
-    @blocking = true
-    attach_function :xs_close, [:pointer], :int
-    @blocking = true
-    attach_function :xs_getsockopt, [:pointer, :int, :pointer, :pointer], :int
-    @blocking = true
-    attach_function :xs_recvmsg, [:pointer, :pointer, :int], :int
-    @blocking = true
-    attach_function :xs_recv, [:pointer, :pointer, :size_t, :int], :int
-    @blocking = true
-    attach_function :xs_sendmsg, [:pointer, :pointer, :int], :int
-    @blocking = true
-    attach_function :xs_send, [:pointer, :pointer, :size_t, :int], :int
-    @blocking = true
-    attach_function :xs_setsockopt, [:pointer, :int, :pointer, :int], :int
-
-    # Poll api
-    @blocking = true
-    attach_function :xs_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 fd() self[:fd]; end
-
-      def readable?
-        (self[:revents] & XS::POLLIN) > 0
-      end
-
-      def writable?
-        (self[:revents] & XS::POLLOUT) > 0
-      end
-
-      def both_accessible?
-        readable? && writable?
-      end
-
-      def inspect
-        "socket [#{socket}], fd [#{fd}], events [#{self[:events]}], revents [#{self[:revents]}]"
-      end
-
-      def to_s; inspect; end
-    end # class PollItem
-
-  end
-
-end # module XS