ffi-rzmq 0.8.2 → 0.9.0

data/lib/ffi-rzmq/util.rb

@@ -0,0 +1,101 @@
+
+module ZMQ
+
+  # These methods don't belong to any specific class. They get included
+  # in the #Context, #Socket and #Poller classes.
+  #
+  module Util
+
+    # Returns true when +rc+ is greater than or equal to 0, false otherwise.
+    #
+    # We use the >= test because zmq_poll() returns the number of sockets
+    # that had a read or write event triggered. So, a >= 0 result means
+    # it succeeded.
+    #
+    def self.resultcode_ok? rc
+      rc >= 0
+    end
+
+    # Returns the +errno+ as set by the libzmq library.
+    #
+    def self.errno
+      LibZMQ.zmq_errno
+    end
+
+    # Returns a string corresponding to the currently set #errno. These
+    # error strings are defined by libzmq.
+    #
+    def self.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
+
+    # Returns the proper flag value for non-blocking regardless of 0mq
+    # version.
+    #
+    if LibZMQ.version2?
+
+      def self.nonblocking_flag
+        NOBLOCK
+      end
+
+    elsif LibZMQ.version3? || LibZMQ.version4?
+      
+      def self.nonblocking_flag
+        DONTWAIT
+      end
+
+    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
+      if -1 == result_code
+        raise_error source, result_code
+      end
+
+      # used by Socket::send/recv, ignored by others
+      true
+    end
+
+    def raise_error source, result_code
+      if 'zmq_init' == source || 'zmq_socket' == source
+        raise ContextError.new source, result_code, ZMQ::Util.errno, ZMQ::Util.error_string
+
+      elsif ['zmq_msg_init', 'zmq_msg_init_data', 'zmq_msg_copy', 'zmq_msg_move'].include?(source)
+        raise MessageError.new source, result_code, ZMQ::Util.errno, ZMQ::Util.error_string
+
+      else
+        puts "else"
+        raise ZeroMQError.new source, result_code, -1,
+        "Source [#{source}] does not match any zmq_* strings, rc [#{result_code}], errno [#{ZMQ::Util.errno}], error_string [#{ZMQ::Util.error_string}]"
+      end
+    end
+
+    def eagain?
+      EAGAIN == ZMQ::Util.errno
+    end
+
+  end # module Util
+
+end # module ZMQ

data/spec/context_spec.rb

@@ -7,10 +7,49 @@ module ZMQ
 
   describe Context do
 
-    context "when initializing" do
+    context "when initializing with factory method #create" do
+      include APIHelper
+
+      it "should return nil for negative io threads" do
+        LibZMQ.stub(:zmq_init => nil)
+        Context.create(-1).should be_nil
+      end
+      
+      it "should default to requesting 1 i/o thread when no argument is passed" do
+        ctx = mock('ctx')
+        ctx.stub!(:null? => false)
+        LibZMQ.should_receive(:zmq_init).with(1).and_return(ctx)
+        
+        Context.create
+      end
+
+      it "should set the :pointer accessor to non-nil" do
+        ctx = Context.create
+        ctx.pointer.should_not be_nil
+      end
+
+      it "should set the :context accessor to non-nil" do
+        ctx = Context.create
+        ctx.context.should_not be_nil
+      end
+
+      it "should set the :pointer and :context accessors to the same value" do
+        ctx = Context.create
+        ctx.pointer.should == ctx.context
+      end
+      
+      it "should define a finalizer on this object" do
+        ObjectSpace.should_receive(:define_finalizer)
+        ctx = Context.create
+      end
+    end # context initializing
+
+
+    context "when initializing with #new" do
       include APIHelper
 
       it "should raise an error for negative io threads" do
+        LibZMQ.stub(:zmq_init => nil)
         lambda { Context.new(-1) }.should raise_exception(ZMQ::ContextError)
       end
       
@@ -23,17 +62,17 @@ module ZMQ
       end
 
       it "should set the :pointer accessor to non-nil" do
-        ctx = spec_ctx
+        ctx = Context.new
         ctx.pointer.should_not be_nil
       end
 
       it "should set the :context accessor to non-nil" do
-        ctx = spec_ctx
+        ctx = Context.new
         ctx.context.should_not be_nil
       end
 
       it "should set the :pointer and :context accessors to the same value" do
-        ctx = spec_ctx
+        ctx = Context.new
         ctx.pointer.should == ctx.context
       end
       
@@ -50,27 +89,14 @@ module ZMQ
         LibZMQ.should_receive(:zmq_term).with(ctx.pointer).and_return(0)
         ctx.terminate
       end
-
-      it "should raise a ZMQ::ContextError exception when it fails" do
-        ctx = Context.new # can't use a shared context here because we are terminating it!
-        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 = spec_ctx
-#        sock = ctx.socket ZMQ::REQ
-#        sock.should be_kind_of(ZMQ::Socket)
-#        # need to do something with the socket so it's in a state that can return ETERM
-#      end
-
-      it "should raise a ZMQ::SocketError exception when allocation fails" do
-        ctx = spec_ctx
-        Socket.stub(:new => nil)
-        lambda { ctx.socket(ZMQ::REQ) }.should raise_error(ZMQ::SocketError)
+      it "should return nil when allocation fails" do
+        ctx = Context.new
+        LibZMQ.stub!(:zmq_socket => nil)
+        ctx.socket(ZMQ::REQ).should be_nil
       end
     end # context socket
 

data/spec/device_spec.rb

@@ -1,69 +1,89 @@
 
 require File.join(File.dirname(__FILE__), %w[spec_helper])
 
-module ZMQ
-  describe Device do
-    include APIHelper
-    
-    def create_streamer
-      @back_addr  = "tcp://127.0.0.1:#{random_port}"
-      @front_addr = "tcp://127.0.0.1:#{random_port}"
-      Thread.new do
-        back  = SPEC_CTX.socket(ZMQ::PULL)
-        back.bind(@back_addr)
-        front = SPEC_CTX.socket(ZMQ::PUSH)
-        front.bind(@front_addr)
-        Device.new(ZMQ::STREAMER, back, front)
+if version2?
+
+  module ZMQ
+    describe Device do
+      include APIHelper
+
+      before(:each) do
+        @ctx = Context.new
       end
-      sleep 0.5
-    end
-    
-    it "should create a streamer device without error given valid opts" do
-      create_streamer
-    end
 
-    it "should be able to send messages through the device" do
-      create_streamer
+      after(:each) do
+        @ctx.terminate
+      end
       
-      pusher = SPEC_CTX.socket(ZMQ::PUSH)
-      pusher.connect(@back_addr)
-      puller = SPEC_CTX.socket(ZMQ::PULL)
-      puller.connect(@front_addr)
+      def create_streamer
+        @backport = @frontport = nil
+        Thread.new do
+          back  = @ctx.socket(ZMQ::PULL)
+          @backport = bind_to_random_tcp_port(back)
+          front = @ctx.socket(ZMQ::PUSH)
+          @frontport = bind_to_random_tcp_port(front)
+          Device.new(ZMQ::STREAMER, back, front)
+          back.close
+          front.close
+        end
+        sleep 0.5
+      end
       
-      pusher.send_string("hello")
-      sleep 0.5
-      res = puller.recv_string(ZMQ::NOBLOCK)
-      res.should == "hello"
-    end
-
-    it "should raise an ArgumentError when trying to pass non-socket objects into the device" do
-      lambda {
-        Device.new(ZMQ::STREAMER, 1,2)
-      }.should raise_exception(ArgumentError)
-    end
-
-    it "should be able to create a forwarder device without error" do
-      back_addr  = "tcp://127.0.0.1:#{random_port}"
-      front_addr = "tcp://127.0.0.1:#{random_port}"
-      Thread.new do
-        back  = SPEC_CTX.socket(ZMQ::SUB)
-        back.bind(back_addr)
-        front = SPEC_CTX.socket(ZMQ::PUB)
-        front.bind(front_addr)
-        Device.new(ZMQ::FORWARDER, back, front)
+      it "should create a streamer device without error given valid opts" do
+        create_streamer
       end
-    end
-     
-    it "should be able to create a queue device without error" do
-      back_addr  = "tcp://127.0.0.1:#{random_port}"
-      front_addr = "tcp://127.0.0.1:#{random_port}"
-      Thread.new do
-        back  = SPEC_CTX.socket(ZMQ::ROUTER)
-        back.bind(back_addr)
-        front = SPEC_CTX.socket(ZMQ::DEALER)
-        front.bind(front_addr)
-        Device.new(ZMQ::QUEUE, back, front)
+      
+      it "should be able to send messages through the device" do
+        create_streamer
+      
+        pusher = @ctx.socket(ZMQ::PUSH)
+        pusher.connect("tcp://127.0.0.1:#{@backport}")
+        puller = @ctx.socket(ZMQ::PULL)
+        puller.connect("tcp://127.0.0.1:#{@frontport}")
+      
+        pusher.send_string("hello")
+        sleep 0.5
+        res = ''
+        rc = puller.recv_string(res, ZMQ::NOBLOCK)
+        res.should == "hello"
+        
+        pusher.close
+        puller.close
+        sleep 0.5
+      end
+      
+      it "should raise an ArgumentError when trying to pass non-socket objects into the device" do
+        lambda {
+          Device.new(ZMQ::STREAMER, 1,2)
+        }.should raise_exception(ArgumentError)
+      end
+      
+      it "should be able to create a forwarder device without error" do
+        Thread.new do
+          back  = @ctx.socket(ZMQ::SUB)
+          bind_to_random_tcp_port(back)
+          front = @ctx.socket(ZMQ::PUB)
+          bind_to_random_tcp_port(front)
+          Device.new(ZMQ::FORWARDER, back, front)
+          back.close
+          front.close
+        end
+        sleep 0.5
+      end
+      
+      it "should be able to create a queue device without error" do
+        Thread.new do
+          back  = @ctx.socket(ZMQ::ROUTER)
+          bind_to_random_tcp_port(back)
+          front = @ctx.socket(ZMQ::DEALER)
+          bind_to_random_tcp_port(front)
+          Device.new(ZMQ::QUEUE, back, front)
+          back.close
+          front.close
+        end
+        sleep 0.5
       end
     end
   end
-end
+
+end # if version2?

data/spec/message_spec.rb

@@ -7,36 +7,114 @@ module ZMQ
   describe Message do
 
     context "when initializing with an argument" do
-      
+
+      it "calls zmq_msg_init_data()" do
+        LibZMQ.should_receive(:zmq_msg_init_data)
+        message = Message.new "text"
+      end
+
       it "should *not* define a finalizer on this object" do
         ObjectSpace.should_not_receive(:define_finalizer)
         Message.new "text"
       end
-    end # context initializing
+    end # context initializing with arg
+
+    context "when initializing *without* an argument" do
 
+      it "calls zmq_msg_init()" do
+        LibZMQ.should_receive(:zmq_msg_init).and_return(0)
+        message = Message.new
+      end
+
+      it "should *not* define a finalizer on this object" do
+        ObjectSpace.should_not_receive(:define_finalizer)
+        Message.new "text"
+      end
+    end # context initializing with arg
 
-    context "when copying in data" do
-      it "should raise a MessageError when the Message is being reused" do
+
+    context "#copy_in_string" do
+      it "calls zmq_msg_init_data()" do
         message = Message.new "text"
-        lambda { message.copy_in_string("new text") }.should raise_error(MessageError)
+
+        LibZMQ.should_receive(:zmq_msg_init_data)
+        message.copy_in_string("new text")
       end
-    end
-    
-    context "when copying binary data" do
-      it "should find the correct length by ignoring encoding" do
+
+      it "correctly finds the length of binary data by ignoring encoding" do
         message = Message.new
         message.copy_in_string("\x83\x6e\x04\x00\x00\x44\xd1\x81")
         message.size.should == 8
       end
     end
 
+
+    context "#copy" do
+      it "calls zmq_msg_copy()" do
+        message = Message.new "text"
+        copy = Message.new
+
+        LibZMQ.should_receive(:zmq_msg_copy)
+        copy.copy(message)
+      end
+    end # context copy
+
+
+    context "#move" do
+      it "calls zmq_msg_move()" do
+        message = Message.new "text"
+        copy = Message.new
+
+        LibZMQ.should_receive(:zmq_msg_move)
+        copy.move(message)
+      end
+    end # context move
+
+
+    context "#size" do
+      it "calls zmq_msg_size()" do
+        message = Message.new "text"
+
+        LibZMQ.should_receive(:zmq_msg_size)
+        message.size
+      end
+    end # context size
+
+
+    context "#data" do
+      it "calls zmq_msg_data()" do
+        message = Message.new "text"
+
+        LibZMQ.should_receive(:zmq_msg_data)
+        message.data
+      end
+    end # context data
+
+
+    context "#close" do
+      it "calls zmq_msg_close() the first time" do
+        message = Message.new "text"
+
+        LibZMQ.should_receive(:zmq_msg_close)
+        message.close
+      end
+
+      it "*does not* call zmq_msg_close() on subsequent invocations" do
+        message = Message.new "text"
+        message.close
+
+        LibZMQ.should_not_receive(:zmq_msg_close)
+        message.close
+      end
+    end # context close
+
   end # describe Message
-  
-  
+
+
   describe ManagedMessage do
 
     context "when initializing with an argument" do
-      
+
       it "should define a finalizer on this object" do
         ObjectSpace.should_receive(:define_finalizer)
         ManagedMessage.new "text"