ffi-rzmq 1.0.3 → 2.0.4

data/lib/ffi-rzmq/util.rb

@@ -5,6 +5,23 @@ module ZMQ
   #
   class Util
 
+    # Generate and return a CURVE public/private keypair
+    #
+    # Raises an error if ZeroMQ is not configured for CURVE connections.
+    # Install libsodium if this is the case.
+    def self.curve_keypair
+      public_key = FFI::MemoryPointer.from_string(' ' * 41)
+      private_key = FFI::MemoryPointer.from_string(' ' * 41)
+      rc = LibZMQ.zmq_curve_keypair public_key, private_key
+
+      if rc < 0
+        raise NotSupportedError.new "zmq_curve_keypair" , rc, ZMQ::Util.errno,
+          "Rebuild zeromq with libsodium to enable CURVE security options."
+      end
+
+      [public_key.read_string, private_key.read_string]
+    end
+
     # 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
@@ -28,19 +45,6 @@ module ZMQ
       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
-
     # Attempts to bind to a random tcp port on +host+ up to +max_tries+
     # times. Returns the port number upon success or nil upon failure.
     #
@@ -56,7 +60,7 @@ module ZMQ
 
       resultcode_ok?(rc) ? random : nil
     end
-    
+
     # :doc:
     # Called to verify whether there were any errors during
     # operation. If any are found, raise the appropriate #ZeroMQError.
@@ -90,38 +94,26 @@ module ZMQ
 
       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}]"
+          "Source [#{source}] does not match any zmq_* strings, rc [#{result_code}], errno [#{ZMQ::Util.errno}], error_string [#{ZMQ::Util.error_string}]"
       end
     end
 
     def self.eagain?
       EAGAIN == ZMQ::Util.errno
     end
-    
-    if LibZMQ.version2?
-      def self.context_error?(source)
-        'zmq_init' == source ||
-        'zmq_socket' == source
-      end
-      
-      def self.message_error?(source)
-        ['zmq_msg_init', 'zmq_msg_init_data', 'zmq_msg_copy', 'zmq_msg_move'].include?(source)
-      end
-      
-    elsif LibZMQ.version3?
-      def self.context_error?(source)
-        'zmq_ctx_new' == source ||
+
+    def self.context_error?(source)
+      'zmq_ctx_new' == source ||
         'zmq_ctx_set' == source ||
         'zmq_ctx_get' == source ||
         'zmq_ctx_destory' == source ||
         'zmq_ctx_set_monitor' == source
-      end
-      
-      def self.message_error?(source)
-        ['zmq_msg_init', 'zmq_msg_init_data', 'zmq_msg_copy', 'zmq_msg_move', 'zmq_msg_close', 'zmq_msg_get',
-          'zmq_msg_more', 'zmq_msg_recv', 'zmq_msg_send', 'zmq_msg_set'].include?(source)
-      end
-    end # if LibZMQ.version...?
+    end
+
+    def self.message_error?(source)
+      ['zmq_msg_init', 'zmq_msg_init_data', 'zmq_msg_copy', 'zmq_msg_move', 'zmq_msg_close', 'zmq_msg_get',
+       'zmq_msg_more', 'zmq_msg_recv', 'zmq_msg_send', 'zmq_msg_set'].include?(source)
+    end
 
   end # module Util
 

data/lib/ffi-rzmq/version.rb

@@ -1,3 +1,3 @@
 module ZMQ
-  VERSION = "1.0.3"
+  VERSION = "2.0.4"
 end

data/spec/context_spec.rb

@@ -11,31 +11,31 @@ module ZMQ
       include APIHelper
 
       it "should return nil for negative io threads" do
-        Context.create(-1).should be_nil
+        expect(Context.create(-1)).to eq(nil)
       end
       
       it "should default to requesting 1 i/o thread when no argument is passed" do
         ctx = Context.create
-        ctx.io_threads.should == 1
+        expect(ctx.io_threads).to eq(1)
       end
 
       it "should set the :pointer accessor to non-nil" do
         ctx = Context.create
-        ctx.pointer.should_not be_nil
+        expect(ctx.pointer).not_to be_nil
       end
 
       it "should set the :context accessor to non-nil" do
         ctx = Context.create
-        ctx.context.should_not be_nil
+        expect(ctx.context).not_to be_nil
       end
 
       it "should set the :pointer and :context accessors to the same value" do
         ctx = Context.create
-        ctx.pointer.should == ctx.context
+        expect(ctx.pointer).to eq(ctx.context)
       end
       
       it "should define a finalizer on this object" do
-        ObjectSpace.should_receive(:define_finalizer)
+        expect(ObjectSpace).to receive(:define_finalizer)
         ctx = Context.create
       end
     end # context initializing
@@ -45,31 +45,31 @@ module ZMQ
       include APIHelper
 
       it "should raise a ContextError exception for negative io threads" do
-        lambda { Context.new(-1) }.should raise_exception(ZMQ::ContextError)
+        expect { Context.new(-1) }.to raise_exception(ZMQ::ContextError)
       end
       
       it "should default to requesting 1 i/o thread when no argument is passed" do
         ctx = Context.new
-        ctx.io_threads.should == 1
+        expect(ctx.io_threads).to eq(1)
       end
 
       it "should set the :pointer accessor to non-nil" do
         ctx = Context.new
-        ctx.pointer.should_not be_nil
+        expect(ctx.pointer).not_to be_nil
       end
 
       it "should set the :context accessor to non-nil" do
         ctx = Context.new
-        ctx.context.should_not be_nil
+        expect(ctx.context).not_to be_nil
       end
 
       it "should set the :pointer and :context accessors to the same value" do
         ctx = Context.new
-        ctx.pointer.should == ctx.context
+        expect(ctx.pointer).to eq(ctx.context)
       end
       
       it "should define a finalizer on this object" do
-        ObjectSpace.should_receive(:define_finalizer)
+        expect(ObjectSpace).to receive(:define_finalizer)
         Context.new 1
       end
     end # context initializing
@@ -79,19 +79,14 @@ module ZMQ
       it "should set the context to nil when terminating the library's context" do
         ctx = Context.new # can't use a shared context here because we are terminating it!
         ctx.terminate
-        ctx.pointer.should be_nil
+        expect(ctx.pointer).to be_nil
       end
       
       it "should call the correct library function to terminate the context" do
         ctx = Context.new
-        
-        if LibZMQ.version2?
-          LibZMQ.should_receive(:zmq_term).and_return(0)
-          ctx.terminate
-        else
-          LibZMQ.should_receive(:zmq_ctx_destroy).with(ctx.pointer).and_return(0)
-          ctx.terminate
-        end
+
+        expect(LibZMQ).to receive(:zmq_ctx_destroy).with(ctx.pointer).and_return(0)
+        ctx.terminate
       end
     end # context terminate
 
@@ -99,8 +94,8 @@ module ZMQ
     context "when allocating a socket" do
       it "should return nil when allocation fails" do
         ctx = Context.new
-        LibZMQ.stub(:zmq_socket => nil)
-        ctx.socket(ZMQ::REQ).should be_nil
+        allow(LibZMQ).to receive(:zmq_socket).and_return(nil)
+        expect(ctx.socket(ZMQ::REQ)).to be_nil
       end
     end # context socket
 

data/spec/device_spec.rb

@@ -5,7 +5,7 @@ module ZMQ
   describe Device do
     include APIHelper
 
-    before(:all) do
+    before(:each) do
       @ctx = Context.new
       poller_setup
       @front_endpoint = "inproc://device_front_test"
@@ -13,7 +13,7 @@ module ZMQ
       @mutex = Mutex.new
     end
 
-    after(:all) do
+    after(:each) do
       @ctx.terminate
     end
 
@@ -26,7 +26,9 @@ module ZMQ
         front = @ctx.socket(ZMQ::PUSH)
         front.bind(@front_endpoint)
         @mutex.synchronize { @device_thread = true }
-        Device.new(ZMQ::STREAMER, back, front)
+        puts "create streamer device and running..."
+        Device.new(back, front)
+        puts "device exited"
         back.close
         front.close
       end
@@ -34,12 +36,11 @@ module ZMQ
     
     def wait_for_device
       loop do
-        can_break = false
-        @mutex.synchronize do
-          can_break = true if @device_thread
-        end
+        can_break = @mutex.synchronize { @device_thread }
+        
         break if can_break
       end
+      puts "broke out of wait_for_device loop"
     end
 
     it "should create a device without error given valid opts" do
@@ -61,17 +62,17 @@ module ZMQ
       end
 
       res = ''
-      rc = puller.recv_string(res, ZMQ::NonBlocking)
-      res.should == "hello"
+      rc = puller.recv_string(res, ZMQ::DONTWAIT)
+      expect(res).to eq("hello")
 
       pusher.close
       puller.close
     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)
+      expect {
+        Device.new(1,2)
+      }.to raise_exception(ArgumentError)
     end
   end
 end

data/spec/message_spec.rb

@@ -9,12 +9,12 @@ module ZMQ
     context "when initializing with an argument" do
 
       it "calls zmq_msg_init_data()" do
-        LibZMQ.should_receive(:zmq_msg_init_data)
+        expect(LibZMQ).to 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)
+        expect(ObjectSpace).not_to receive(:define_finalizer)
         Message.new "text"
       end
     end # context initializing with arg
@@ -22,12 +22,12 @@ module ZMQ
     context "when initializing *without* an argument" do
 
       it "calls zmq_msg_init()" do
-        LibZMQ.should_receive(:zmq_msg_init).and_return(0)
+        expect(LibZMQ).to 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)
+        expect(ObjectSpace).not_to receive(:define_finalizer)
         Message.new "text"
       end
     end # context initializing with arg
@@ -37,14 +37,14 @@ module ZMQ
       it "calls zmq_msg_init_data()" do
         message = Message.new "text"
 
-        LibZMQ.should_receive(:zmq_msg_init_data)
+        expect(LibZMQ).to receive(:zmq_msg_init_data)
         message.copy_in_string("new text")
       end
 
       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
+        expect(message.size).to eq(8)
       end
     end
 
@@ -54,7 +54,7 @@ module ZMQ
         message = Message.new "text"
         copy = Message.new
 
-        LibZMQ.should_receive(:zmq_msg_copy)
+        expect(LibZMQ).to receive(:zmq_msg_copy)
         copy.copy(message)
       end
     end # context copy
@@ -65,7 +65,7 @@ module ZMQ
         message = Message.new "text"
         copy = Message.new
 
-        LibZMQ.should_receive(:zmq_msg_move)
+        expect(LibZMQ).to receive(:zmq_msg_move)
         copy.move(message)
       end
     end # context move
@@ -75,7 +75,7 @@ module ZMQ
       it "calls zmq_msg_size()" do
         message = Message.new "text"
 
-        LibZMQ.should_receive(:zmq_msg_size)
+        expect(LibZMQ).to receive(:zmq_msg_size)
         message.size
       end
     end # context size
@@ -85,7 +85,7 @@ module ZMQ
       it "calls zmq_msg_data()" do
         message = Message.new "text"
 
-        LibZMQ.should_receive(:zmq_msg_data)
+        expect(LibZMQ).to receive(:zmq_msg_data)
         message.data
       end
     end # context data
@@ -95,7 +95,7 @@ module ZMQ
       it "calls zmq_msg_close() the first time" do
         message = Message.new "text"
 
-        LibZMQ.should_receive(:zmq_msg_close)
+        expect(LibZMQ).to receive(:zmq_msg_close)
         message.close
       end
 
@@ -103,7 +103,7 @@ module ZMQ
         message = Message.new "text"
         message.close
 
-        LibZMQ.should_not_receive(:zmq_msg_close)
+        expect(LibZMQ).not_to receive(:zmq_msg_close)
         message.close
       end
     end # context close
@@ -116,7 +116,7 @@ module ZMQ
     context "when initializing with an argument" do
 
       it "should define a finalizer on this object" do
-        ObjectSpace.should_receive(:define_finalizer)
+        expect(ObjectSpace).to receive(:define_finalizer)
         ManagedMessage.new "text"
       end
     end # context initializing

data/spec/multipart_spec.rb

@@ -29,7 +29,7 @@ module ZMQ
           sleep 1
           strings = []
           rc = @receiver.recv_strings(strings)
-          strings.should == data
+          expect(strings).to eq(data)
         end
       end
 
@@ -56,12 +56,12 @@ module ZMQ
           @req.send_strings(req_data)
           strings = []
           rc = @rep.recv_strings(strings)
-          strings.should == req_data
+          expect(strings).to eq(req_data)
 
           @rep.send_strings(rep_data)
           strings = []
           rc = @req.recv_strings(strings)
-          strings.should == rep_data
+          expect(strings).to eq(rep_data)
         end
 
         it "should be delivered between REQ and REP returning an array of messages" do
@@ -71,14 +71,14 @@ module ZMQ
           messages = []
           rc = @rep.recvmsgs(messages)
           messages.each_with_index do |message, index|
-            message.copy_out_string.should == req_data[index]
+            expect(message.copy_out_string).to eq(req_data[index])
           end
 
           @rep.send_strings(rep_data)
           messages = []
           rc = @req.recvmsgs(messages)
           messages.each_with_index do |message, index|
-            message.copy_out_string.should == rep_data[index]
+            expect(message.copy_out_string).to eq(rep_data[index])
           end
         end
       end
@@ -106,12 +106,12 @@ module ZMQ
             @req.send_string(req_data)
             strings = []
             rc = @rep.recv_strings(strings)
-            strings.should == [ @req.identity, "", "hello" ]
+            expect(strings).to eq([ @req.identity, "", "hello" ])
 
             @rep.send_strings(rep_data)
             string = ''
             rc = @req.recv_string(string)
-            string.should == rep_data.last
+            expect(string).to eq(rep_data.last)
           end
 
           it "should be delivered between REQ and REP returning an array of messages with an empty string as the envelope delimiter" do
@@ -120,14 +120,14 @@ module ZMQ
             @req.send_string(req_data)
             msgs = []
             rc = @rep.recvmsgs(msgs)
-            msgs[0].copy_out_string.should == @req.identity
-            msgs[1].copy_out_string.should == ""
-            msgs[2].copy_out_string.should == "hello"
+            expect(msgs[0].copy_out_string).to eq(@req.identity)
+            expect(msgs[1].copy_out_string).to eq("")
+            expect(msgs[2].copy_out_string).to eq("hello")
 
             @rep.send_strings(rep_data)
             msgs = []
             rc = @req.recvmsgs(msgs)
-            msgs[0].copy_out_string.should == rep_data.last
+            expect(msgs[0].copy_out_string).to eq(rep_data.last)
           end
         end