rbzmq 0.1.0

data/lib/rbzmq/version.rb

@@ -0,0 +1,14 @@
+module RbZMQ
+  module VERSION
+    MAJOR = 0
+    MINOR = 1
+    PATCH = 0
+    STAGE = nil
+
+    STRING = [MAJOR, MINOR, PATCH, STAGE].reject(&:nil?).join('.').freeze
+
+    def self.to_s
+      STRING
+    end
+  end
+end

data/rbzmq.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rbzmq/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'rbzmq'
+  spec.version       = RbZMQ::VERSION
+  spec.authors       = ['Jan Graichen']
+  spec.email         = ['jg@altimos.de']
+  spec.summary       = %q{An opinionated ruby library wrapping ffi-rzmq for more rubish flair.}
+  spec.description   = %q{An opinionated ruby library wrapping ffi-rzmq for more rubish flair.}
+  spec.homepage      = 'https://github.com/jgraichen/rbzmq'
+  spec.license       = 'LGPLv3'
+
+  spec.files         = Dir['**/*'].grep(%r{^((bin|lib|test|spec|features)/|.*\.gemspec|.*LICENSE.*|.*README.*|.*CHANGELOG.*)})
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'ffi-rzmq', '~> 2.0'
+
+  spec.add_development_dependency 'bundler', '~> 1.5'
+end

data/spec/functional/rbzmq/poller_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe RbZMQ::Poller do
+  let!(:poller) { RbZMQ::Poller.new }
+  let!(:receiver) do
+    RbZMQ::Socket.new(ZMQ::PULL).tap{|s| s.bind 'inproc://test' }
+  end
+  let!(:sender) do
+    RbZMQ::Socket.new(ZMQ::PUSH).tap{|s| s.connect 'inproc://test' }
+  end
+  let(:delta) { 0.01 }
+  after { receiver.close! }
+  after { sender.close! }
+
+  describe '#register' do
+    let(:action) { -> { poller.register(receiver, ZMQ::POLLIN) } }
+    subject { action }
+
+    it { should change(poller, :size).from(0).to(1) }
+  end
+
+  describe '#deregister' do
+    let(:action) { -> { poller.deregister(receiver, ZMQ::POLLIN) } }
+    subject { action }
+
+    context 'with all events removed' do
+      before { poller.register(receiver, ZMQ::POLLIN) }
+      it { should change(poller, :size).from(1).to(0) }
+    end
+
+    context 'with events leaving' do
+      before { poller.register(receiver, ZMQ::POLLIN | ZMQ::POLLOUT) }
+      it { should_not change(poller, :size) }
+      it { expect(subject.call).to eq ZMQ::POLLOUT }
+    end
+  end
+
+  describe '#poll' do
+    let!(:start_time) { Time.now.to_f }
+    let(:end_time) { Time.now.to_f }
+
+    context 'without any registered' do
+      it 'should not block' do
+        poller.poll(1_000)
+        expect(end_time).to be_within(delta).of(start_time)
+      end
+    end
+
+    context 'with registered ZMQ socket' do
+      before { poller.register(receiver, ZMQ::POLLIN) }
+
+      it 'should timeout without event' do
+        poller.poll(100)
+        expect(end_time).to be > (start_time + 0.1)
+      end
+
+      it 'should interrupt on event' do
+        Thread.new do
+          sleep 0.1
+          sender.send 'MSG'
+        end
+        poller.poll(1_000)
+        expect(receiver.recv.to_s).to eq 'MSG'
+        expect(end_time).to be < (start_time + 1.0)
+      end
+    end
+
+    context 'with registered IO' do
+      let(:pipe)   { IO.pipe }
+      let(:reader) { pipe[0] }
+      let(:writer) { pipe[1] }
+      before { poller.register(reader, ZMQ::POLLIN) }
+
+      it 'should timeout without event' do
+        ret = poller.poll(100)
+        expect(ret).to be_a Enumerator
+        expect(ret).to have(0).items
+        expect(end_time).to be > (start_time + 0.1)
+      end
+
+      it 'should interrupt on event' do
+        Thread.new do
+          sleep 0.1
+          writer.write 'MSG'
+          writer.close
+        end
+        ret = poller.poll(1_000)
+        expect(end_time).to be < (start_time + 1.0)
+        expect(ret).to be_a Enumerator
+        expect(ret).to have(1).item
+        expect(reader.read_nonblock(4096)).to eq 'MSG'
+      end
+    end
+  end
+end

data/spec/functional/rbzmq/socket_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe RbZMQ::Socket do
+  let!(:server) do
+    described_class.new(ZMQ::PULL).tap{|s| s.bind 'inproc://test' }
+  end
+  after { server.close! }
+
+  let!(:socket) { described_class.new(ZMQ::PUSH) }
+  after { socket.close! }
+
+  describe 'recv' do
+    describe 'timeout' do
+      before do
+        socket.connect 'inproc://test'
+      end
+
+      it 'should poll messages' do
+        Thread.new do
+          sleep 0.2
+          socket.send 'TEST'
+        end
+
+        start = Time.now
+        str   = server.recv(timeout: 1000).to_s
+
+        expect(Time.now - start).to be < 1
+        expect(str).to eq 'TEST'
+      end
+
+      it 'should raise error when timeout is reached' do
+        start = Time.now
+
+        expect{ server.recv(timeout: 1000).to_s }.to raise_error Errno::EAGAIN
+
+        expect(Time.now - start).to be_within(0.1).of(1)
+      end
+    end
+  end
+end

data/spec/rbzmq/socket_spec.rb

@@ -0,0 +1,255 @@
+require 'spec_helper'
+
+describe RbZMQ::Socket do
+  let(:socket) { RbZMQ::Socket.new ZMQ::ROUTER }
+
+  describe '#initialize' do
+    let(:opts) { Hash.new }
+    let(:socket) { RbZMQ::Socket.new ZMQ::ROUTER, opts }
+
+    context 'opts: ctx' do
+      let(:opts) { {ctx: ctx} }
+
+      context 'with valid ctx' do
+        subject { socket }
+
+        context 'with ZMQ::Context' do
+          let(:ctx) { ZMQ::Context.new }
+          it { expect(socket.zmq_ctx).to eq ctx.pointer }
+        end
+
+        context 'with RbZMQ::Context' do
+          let(:ctx) { RbZMQ::Context.new }
+          it { expect(socket.zmq_ctx).to eq ctx.pointer }
+        end
+      end
+
+      context 'with invalid object' do
+        subject { ->{ socket } }
+
+        context 'with String' do
+          let(:ctx) { '' }
+          it { should raise_error ArgumentError }
+        end
+      end
+    end
+
+    context 'with ZMQ raising an error' do
+      let(:zmq_err) { ZMQ::ZeroMQError.new('zmq_source', 42, 21, 'abc MSG') }
+      before do
+        expect(ZMQ::Socket).to receive(:new).and_raise zmq_err
+      end
+
+      subject do
+        begin
+          socket
+        rescue => err
+          err
+        end
+      end
+
+      it { should be_a RbZMQ::ZMQError }
+      its(:rc) { should eq 42 }
+      its(:result_code) { should eq 42 }
+      its(:errno) { should eq 21 }
+      its(:error_code) { should eq 21 }
+      its(:message) { should eq 'abc MSG' }
+      its(:to_s) { should eq '[ERRNO 21, RC 42] abc MSG' }
+    end
+  end
+
+  describe '#close' do
+    subject { socket.close }
+
+    it 'should successfully call #close on ZMQ socket' do
+      expect(socket.zmq_socket).to receive(:close).and_return(0)
+      expect(subject).to eq true
+    end
+
+    it 'should return false on failure' do
+      expect(socket.zmq_socket).to receive(:close).and_return(-1)
+      should eq false
+    end
+  end
+
+  describe '#close!' do
+    subject { socket.close! }
+
+    it 'should successfully call #close on ZMQ socket' do
+      expect(socket.zmq_socket).to receive(:close)
+      expect(subject).to eq true
+    end
+
+    it 'should raise error on failure' do
+      expect(socket.zmq_socket).to receive(:close).and_return(-1)
+      expect { subject }.to raise_error RbZMQ::ZMQError
+    end
+  end
+
+  describe '#bind' do
+    subject { socket.bind 'tcp://127.0.0.1:5555' }
+
+    it 'should successfully call #bind on ZMQ socket' do
+      expect(socket.zmq_socket).to receive(:bind)
+                                   .with('tcp://127.0.0.1:5555').and_return(0)
+      expect(subject).to eq socket
+    end
+
+    it 'should raise error on failure' do
+      expect(socket.zmq_socket).to receive(:bind).and_return(-1)
+      expect { subject }.to raise_error RbZMQ::ZMQError
+    end
+  end
+
+  describe '#connect' do
+    subject { socket.connect 'tcp://127.0.0.1:5555' }
+
+    it 'should successfully call #connect on ZMQ socket' do
+      expect(socket.zmq_socket).to receive(:connect)
+                                   .with('tcp://127.0.0.1:5555').and_return(0)
+      expect(subject).to eq socket
+    end
+
+    it 'should raise error on failure' do
+      expect(socket.zmq_socket).to receive(:connect).and_return(-1)
+      expect { subject }.to raise_error RbZMQ::ZMQError
+    end
+  end
+
+  describe '#send' do
+    context 'with single message' do
+      let(:dup) { double('ZMQMSG') }
+      let(:msg) { RbZMQ::Message.new }
+      let(:args) { [msg, 42] }
+      subject { socket.send(*args) }
+      before { allow(msg).to receive(:to_zmq).and_return(dup) }
+
+      it 'should successfully call #sendmsg on ZMQ socket' do
+        expect(socket.zmq_socket).to receive(:sendmsg)
+                                     .with(dup, 42).and_return(0)
+        expect(subject).to eq socket
+      end
+
+      it 'should raise error on failure' do
+        expect(socket.zmq_socket).to receive(:sendmsg).and_return(-1)
+        expect { subject }.to raise_error RbZMQ::ZMQError
+      end
+
+      context 'with :block option' do
+        let(:args) { [msg, {block: false}] }
+
+        it 'should set ZMQ::DONTWAIT flag' do
+          expect(socket.zmq_socket).to receive(:sendmsg)
+                                       .with(dup, ZMQ::DONTWAIT).and_return(0)
+          expect(subject).to eq socket
+        end
+      end
+
+      context 'with :more option' do
+        let(:args) { [msg, {more: true}] }
+
+        it 'should set ZMQ::SNDMORE flag' do
+          expect(socket.zmq_socket).to receive(:sendmsg)
+                                       .with(dup, ZMQ::SNDMORE).and_return(0)
+          expect(subject).to eq socket
+        end
+      end
+    end
+
+    context 'with multiple messages' do
+      let(:dup1) { double('msg1') }
+      let(:dup2) { double('msg2') }
+      let(:msg1) { RbZMQ::Message.new }
+      let(:msg2) { RbZMQ::Message.new }
+      let(:args) { [[msg1, msg2]] }
+      subject { socket.send(*args) }
+      before { allow(msg1).to receive(:to_zmq).and_return(dup1) }
+      before { allow(msg2).to receive(:to_zmq).and_return(dup2) }
+
+      it 'should successfully call #sendmsg on ZMQ socket' do
+        expect(socket.zmq_socket).to receive(:sendmsg)
+          .with(dup1, ZMQ::SNDMORE).ordered.and_return(0)
+        expect(socket.zmq_socket).to receive(:sendmsg)
+          .with(dup2, 0).ordered.and_return(0)
+        expect(subject).to eq socket
+      end
+
+      it 'should raise error on failure' do
+        expect(socket.zmq_socket).to receive(:sendmsg)
+          .with(dup1, ZMQ::SNDMORE).ordered.and_return(-1)
+        expect { subject }.to raise_error RbZMQ::ZMQError
+      end
+
+      context 'with :block option' do
+        let(:args) { super() + [{block: false}] }
+
+        it 'should successfully call #sendmsg on ZMQ socket' do
+          expect(socket.zmq_socket).to receive(:sendmsg)
+            .with(dup1, ZMQ::SNDMORE | ZMQ::DONTWAIT).ordered.and_return(0)
+          expect(socket.zmq_socket).to receive(:sendmsg)
+            .with(dup2, ZMQ::DONTWAIT).ordered.and_return(0)
+          expect(subject).to eq socket
+        end
+      end
+
+      context 'with :more option' do
+        let(:args) { super() + [{more: true}] }
+
+        it 'should successfully call #sendmsg on ZMQ socket' do
+          expect(socket.zmq_socket).to receive(:sendmsg)
+            .with(dup1, ZMQ::SNDMORE).ordered.and_return(0)
+          expect(socket.zmq_socket).to receive(:sendmsg)
+            .with(dup2, ZMQ::SNDMORE).ordered.and_return(0)
+          expect(subject).to eq socket
+        end
+      end
+    end
+
+    context 'with single string' do
+      subject { socket.send 'abc', 42 }
+
+      it 'should successfully call #send_string on ZMQ socket' do
+        expect(socket.zmq_socket).to receive(:sendmsg)
+          .with(kind_of(ZMQ::Message), 42).and_return(0)
+        expect(subject).to eq socket
+      end
+
+      it 'should raise error on failure' do
+        expect(socket.zmq_socket).to receive(:sendmsg).and_return(-1)
+        expect { subject }.to raise_error RbZMQ::ZMQError
+      end
+    end
+
+    context 'with multiple strings' do
+      subject { socket.send %w(abc cde), 0 }
+
+      it 'should successfully call #send_strings on ZMQ socket' do
+        expect(socket.zmq_socket).to receive(:sendmsg).ordered
+          .with(kind_of(ZMQ::Message), ZMQ::SNDMORE).and_return(0)
+        expect(socket.zmq_socket).to receive(:sendmsg).ordered
+          .with(kind_of(ZMQ::Message), 0).and_return(0)
+        expect(subject).to eq socket
+      end
+
+      it 'should raise error on failure' do
+        expect(socket.zmq_socket).to receive(:sendmsg).and_return(-1)
+        expect { subject }.to raise_error RbZMQ::ZMQError
+      end
+    end
+  end
+
+  describe '#setsockopt' do
+    subject { socket.setsockopt(ZMQ::SUBSCRIBE, 'ABC') }
+
+    it 'should call #setsockopt on ZMQ socket' do
+      expect(socket.zmq_socket).to receive(:setsockopt)
+                                   .with(ZMQ::SUBSCRIBE, 'ABC').and_return(0)
+      expect(subject).to eq true
+    end
+
+    it 'should return false on failure' do
+      expect(socket.zmq_socket).to receive(:setsockopt).and_return(-1)
+      expect(subject).to eq false
+    end
+  end
+end

data/spec/scripts/test.rb

@@ -0,0 +1,5 @@
+$LOAD_PATH << File.expand_path("../../../lib", __FILE__)
+
+require "rbzmq"
+
+socket = RbZMQ::Socket.new ZMQ::ROUTER

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+require 'bundler'
+Bundler.require :default, :test
+
+if ENV['CI'] || (defined?(:RUBY_ENGINE) && RUBY_ENGINE != 'rbx')
+  require 'coveralls'
+  Coveralls.wear! do
+    add_filter 'spec'
+  end
+end
+
+require 'rbzmq'
+
+Dir[File.expand_path('spec/support/**/*.rb')].each {|f| require f}
+
+RSpec.configure do |config|
+  config.order = 'random'
+
+  config.around do |example|
+    begin
+      Timeout.timeout(30) do
+        example.call
+      end
+    rescue
+      raise Timeout::Error.new 'Spec exceeded maximum execution time'
+    end
+  end
+end