ffi-rzmq 0.5.0

data/lib/ffi-rzmq/zmq.rb

@@ -0,0 +1,147 @@
+
+module ZMQ
+
+  #  Socket types
+  PAIR = 0
+  PUB = 1
+  SUB = 2
+  REQ = 3
+  REP = 4
+  XREQ = 5
+  XREP = 6
+  UPSTREAM = 7
+  DOWNSTREAM = 8
+
+  #  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
+
+  #  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
+
+  # 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.
+    #
+    def 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
+
+
+    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
+      queue_operation = eagain? && !result_code.zero? ? false : true
+      queue_operation
+    end
+
+    def raise_error source, result_code
+      case source
+      when ZMQ_SOCKET_STR, ZMQ_SETSOCKOPT_STR, ZMQ_GETSOCKOPT_STR, ZMQ_BIND_STR, ZMQ_CONNECT_STR, ZMQ_SEND_STR, ZMQ_RECV_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
+      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

data/spec/context_spec.rb

@@ -0,0 +1,96 @@
+
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+module ZMQ
+
+
+  describe Context do
+
+    context "when initializing" do
+      include APIHelper
+
+      it "should raise an error for negative io threads" do
+        lambda { Context.new(-1) }.should raise_exception(ZMQ::ContextError)
+      end
+
+      it "should set the :pointer accessor to non-nil" do
+        ctx = Context.new 1
+        ctx.pointer.should_not be_nil
+      end
+
+      it "should set the :context accessor to non-nil" do
+        ctx = Context.new 1
+        ctx.context.should_not be_nil
+      end
+
+      it "should set the :pointer and :context accessors to the same value" do
+        ctx = Context.new 1
+        ctx.pointer.should == ctx.context
+      end
+      
+      it "should define a finalizer on this object" do
+        ObjectSpace.should_receive(:define_finalizer)
+        ctx = Context.new 1
+      end
+    end # context initializing
+
+
+    context "when terminating" do
+      it "should call zmq_term to terminate the library's context" do
+        ctx = Context.new 1
+        LibZMQ.should_receive(:zmq_term).with(ctx.pointer).and_return(0)
+        ctx.terminate
+      end
+
+      it "should raise an exception when it fails" do
+        ctx = Context.new 1
+        LibZMQ.stub(:zmq_term => 1)
+        lambda { ctx.terminate }.should raise_error(ZMQ::ContextError)
+      end
+    end # context terminate
+
+
+    context "when allocating a socket" do
+      it "should return a ZMQ::Socket" do
+        ctx = Context.new 1
+        ctx.socket(ZMQ::REQ).should be_kind_of(ZMQ::Socket)
+      end
+
+      it "should raise an exception when allocation fails" do
+        ctx = Context.new 1
+        Socket.stub(:new => nil)
+        lambda { ctx.socket(ZMQ::REQ) }.should raise_error(ZMQ::SocketError)
+      end
+    end # context socket
+
+
+#    context "when allocating a device" do
+#      let(:ctx) { Context.new 1 }
+#      let(:sock1) { ctx.socket ZMQ::REQ }
+#      let(:sock2) { ctx.socket ZMQ::REP }
+#
+#      it "should return a ZMQ::Forwarder" do
+#        device = ctx.device ZMQ::FORWARDER, sock1, sock2
+#        device.should be_kind_of(ZMQ::Forwarder)
+#      end
+#
+#      it "should return a ZMQ::Queue" do
+#        device = ctx.device ZMQ::QUEUE, sock1, sock2
+#        device.should be_kind_of(ZMQ::Queue)
+#      end
+#
+#      it "should return a ZMQ::Streamer" do
+#        device = ctx.device ZMQ::STREAMER, sock1, sock2
+#        device.should be_kind_of(ZMQ::Streamer)
+#      end
+#
+#      it "should raise an exception when the requested device is unknown" do
+#        lambda { ctx.device(-1, sock1, sock2) }.should raise_error(ZMQ::DeviceError)
+#      end
+#    end # context device
+
+
+  end # describe Context
+
+
+end # module ZMQ

data/spec/reqrep_spec.rb

@@ -0,0 +1,56 @@
+
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+module ZMQ
+
+
+  describe Context do
+
+    context "when running ping pong" do
+      include APIHelper
+
+      let(:string) { "booga-booga" }
+
+      before(:each) do
+        context = ZMQ::Context.new 1
+        @ping = context.socket ZMQ::REQ
+        @pong = context.socket ZMQ::REP
+        link = "tcp://127.0.0.1:#{random_port}"
+        @pong.bind link
+        @ping.connect link
+      end
+
+      it "should receive an exact string copy of the string message sent" do
+        @ping.send_string string
+        received_message = @pong.recv_string
+
+        received_message.should == string
+      end
+
+      it "should receive an exact copy of the sent message using Message objects directly" do
+        sent_message = Message.new string
+        received_message = Message.new
+
+        @ping.send sent_message
+        @pong.recv received_message
+
+        received_message.copy_out_string.should == string
+      end
+
+      it "should receive an exact copy of the sent message using Message objects directly in non-blocking mode" do
+        sent_message = Message.new string
+        received_message = Message.new
+
+        @ping.send sent_message, ZMQ::NOBLOCK
+        sleep 0.001 # give it time for delivery
+        @pong.recv received_message, ZMQ::NOBLOCK
+
+        received_message.copy_out_string.should == string
+      end
+    end # context ping-pong
+
+
+  end # describe
+
+
+end # module ZMQ

data/spec/socket_spec.rb

@@ -0,0 +1,111 @@
+
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+module ZMQ
+
+
+  describe Socket do
+
+    context "when initializing" do
+
+      let(:ctx) { Context.new 1 }
+      
+      it "should raise an error for a nil context" do
+        lambda { Socket.new(FFI::Pointer::NULL, ZMQ::REQ) }.should raise_exception(ZMQ::ContextError)
+      end
+
+      it "should not raise an error for a ZMQ::REQ socket type" do
+        lambda { Socket.new(ctx.pointer, ZMQ::REQ) }.should_not raise_error
+      end
+
+      it "should not raise an error for a ZMQ::REP socket type" do
+        lambda { Socket.new(ctx.pointer, ZMQ::REP) }.should_not raise_error
+      end
+
+      it "should not raise an error for a ZMQ::PUB socket type" do
+        lambda { Socket.new(ctx.pointer, ZMQ::PUB) }.should_not raise_error
+      end
+
+      it "should not raise an error for a ZMQ::SUB socket type" do
+        lambda { Socket.new(ctx.pointer, ZMQ::SUB) }.should_not raise_error
+      end
+
+      it "should not raise an error for a ZMQ::PAIR socket type" do
+        lambda { Socket.new(ctx.pointer, ZMQ::PAIR) }.should_not raise_error
+      end
+
+      it "should not raise an error for a ZMQ::XREQ socket type" do
+        lambda { Socket.new(ctx.pointer, ZMQ::XREQ) }.should_not raise_error
+      end
+
+      it "should not raise an error for a ZMQ::XREP socket type" do
+        lambda { Socket.new(ctx.pointer, ZMQ::XREP) }.should_not raise_error
+      end
+
+      it "should not raise an error for a ZMQ::DOWNSTREAM socket type" do
+        lambda { Socket.new(ctx.pointer, ZMQ::DOWNSTREAM) }.should_not raise_error
+      end
+
+      it "should not raise an error for a ZMQ::UPSTREAM socket type" do
+        lambda { Socket.new(ctx.pointer, ZMQ::UPSTREAM) }.should_not raise_error
+      end
+
+      it "should raise an error for an unknown socket type" do
+        lambda { Socket.new(ctx.pointer, 80) }.should raise_exception(ZMQ::SocketError)
+      end
+
+      it "should set the :socket accessor to non-nil" do
+        sock = Socket.new(Context.new(1).pointer, ZMQ::REQ)
+        sock.socket.should_not be_nil
+      end
+
+      it "should define a finalizer on this object" do
+        ObjectSpace.should_receive(:define_finalizer)
+        ctx = Context.new 1
+      end
+    end # context initializing
+    
+    
+    context "identity=" do
+      it "should raise an exception for identities in excess of 255 bytes" do
+        ctx = Context.new 1
+        sock = Socket.new ctx.pointer, ZMQ::REQ
+        
+        lambda { sock.identity = ('a' * 256) }.should raise_exception(ZMQ::SocketError)
+      end
+
+      it "should raise an exception for identities of length 0" do
+        ctx = Context.new 1
+        sock = Socket.new ctx.pointer, ZMQ::REQ
+        
+        lambda { sock.identity = '' }.should raise_exception(ZMQ::SocketError)
+      end
+
+      it "should NOT raise an exception for identities of 1 byte" do
+        ctx = Context.new 1
+        sock = Socket.new ctx.pointer, ZMQ::REQ
+        
+        lambda { sock.identity = 'a' }.should_not raise_exception(ZMQ::SocketError)
+      end
+
+      it "should NOT raise an exception for identities of 255 bytes" do
+        ctx = Context.new 1
+        sock = Socket.new ctx.pointer, ZMQ::REQ
+        
+        lambda { sock.identity = ('a' * 255) }.should_not raise_exception(ZMQ::SocketError)
+      end
+
+      it "should convert numeric identities to strings" do
+        ctx = Context.new 1
+        sock = Socket.new ctx.pointer, ZMQ::REQ
+        
+        sock.identity = 7
+        sock.identity.should == '7'
+      end
+    end # context identity=
+    
+    
+  end # describe Socket
+
+
+end # module ZMQ

data/spec/spec_helper.rb

@@ -0,0 +1,38 @@
+# To run these specs using rake, make sure the 'bones' and 'bones-extras'
+# gems are installed. Then execute 'rake spec' from the main directory
+# to run all specs.
+
+require File.expand_path(
+File.join(File.dirname(__FILE__), %w[.. lib ffi-rzmq]))
+
+# turns off all warnings; added so I don't have to see the warnings
+# for included libraries like FFI.
+$VERBOSE = false
+
+Spec::Runner.configure do |config|
+  # == Mock Framework
+  #
+  # RSpec uses it's own mocking framework by default. If you prefer to
+  # use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+end
+
+module APIHelper
+  def stub_libzmq
+    @err_str_mock = mock("error string")
+
+    LibZMQ.stub!(
+    :zmq_init => 0,
+    :zmq_errno => 0,
+    :zmq_sterror => @err_str_mock
+    )
+  end
+
+  # generate a random port between 10_000 and 65534
+  def random_port
+    rand(55534) + 10_000
+  end
+end