ffi-rxs 1.0.0

data/spec/socket_spec.rb

@@ -0,0 +1,496 @@
+
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+module XS
+
+
+  describe Socket do
+
+    socket_types = [XS::REQ, XS::REP, XS::DEALER, XS::ROUTER, XS::PUB, XS::SUB, XS::PUSH, XS::PULL, XS::PAIR, XS::XPUB, XS::XSUB]
+
+    context "when initializing" do
+      before(:all) { @ctx = Context.new }
+      after(:all) { @ctx.terminate }
+
+
+      it "should raise an error for a nil context" do
+        lambda { Socket.new(FFI::Pointer.new(0), XS::REQ) }.should raise_exception(XS::ContextError)
+      end
+
+      it "works with a Context#pointer as the context_ptr" do
+        lambda do
+          s = Socket.new(@ctx.pointer, XS::REQ)
+          s.close
+        end.should_not raise_exception(XS::ContextError)
+      end
+
+      it "works with a Context instance as the context_ptr" do
+        lambda do
+          s = Socket.new(@ctx, XS::SUB)
+          s.close
+        end.should_not raise_exception(XS::ContextError)
+      end
+
+
+      socket_types.each do |socket_type|
+
+        it "should not raise an error for a [#{XS::SocketTypeNameMap[socket_type]}] socket type" do
+          sock = nil
+          lambda { sock = Socket.new(@ctx.pointer, socket_type) }.should_not raise_error
+          sock.close
+        end
+      end # each socket_type
+
+      it "should set the :socket accessor to the raw socket allocated by libxs" do
+        socket = mock('socket')
+        socket.stub!(:null? => false)
+        LibXS.should_receive(:xs_socket).and_return(socket)
+
+        sock = Socket.new(@ctx.pointer, XS::REQ)
+        sock.socket.should == socket
+      end
+
+      it "should define a finalizer on this object" do
+        ObjectSpace.should_receive(:define_finalizer).at_least(1)
+        sock = Socket.new(@ctx.pointer, XS::REQ)
+        sock.close
+      end
+    end # context initializing
+
+
+    context "calling close" do
+      before(:all) { @ctx = Context.new }
+      after(:all) { @ctx.terminate }
+
+      it "should call LibXS.close only once" do
+        sock = Socket.new @ctx.pointer, XS::REQ
+        raw_socket = sock.socket
+
+        LibXS.should_receive(:close).with(raw_socket)
+        sock.close
+        sock.close
+        LibXS.close raw_socket # *really close it otherwise the context will block indefinitely
+      end
+    end # context calling close
+
+
+    context "identity=" do
+      before(:all) { @ctx = Context.new }
+      after(:all) { @ctx.terminate }
+
+      it "fails to set identity for identities in excess of 255 bytes" do
+        sock = Socket.new @ctx.pointer, XS::REQ
+
+        sock.identity = ('a' * 256)
+        sock.identity.should == ''
+        sock.close
+      end
+
+      it "fails to set identity for identities of length 0" do
+        sock = Socket.new @ctx.pointer, XS::REQ
+
+        sock.identity = ''
+        sock.identity.should == ''
+        sock.close
+      end
+
+      it "sets the identity for identities of 1 byte" do
+        sock = Socket.new @ctx.pointer, XS::REQ
+
+        sock.identity = 'a'
+        sock.identity.should == 'a'
+        sock.close
+      end
+
+      it "set the identity identities of 255 bytes" do
+        sock = Socket.new @ctx.pointer, XS::REQ
+
+        sock.identity = ('a' * 255)
+        sock.identity.should == ('a' * 255)
+        sock.close
+      end
+
+      it "should convert numeric identities to strings" do
+        sock = Socket.new @ctx.pointer, XS::REQ
+
+        sock.identity = 7
+        sock.identity.should == '7'
+        sock.close
+      end
+    end # context identity=
+
+
+    socket_types.each do |socket_type|
+
+      context "#setsockopt for a #{XS::SocketTypeNameMap[socket_type]} socket" do
+        before(:all) { @ctx = Context.new }
+        after(:all) { @ctx.terminate }
+
+        let(:socket) do
+          Socket.new @ctx.pointer, socket_type
+        end
+
+        after(:each) do
+          socket.close
+        end
+        
+
+        context "using option XS::IDENTITY" do
+          it "should set the identity given any string under 255 characters" do
+            length = 4
+            (1..255).each do |length|
+              identity = 'a' * length
+              socket.setsockopt XS::IDENTITY, identity
+
+              array = []
+              rc = socket.getsockopt(XS::IDENTITY, array)
+              rc.should == 0
+              array[0].should == identity
+            end
+          end
+
+          it "returns -1 given a string 256 characters or longer" do
+            identity = 'a' * 256
+            array = []
+            rc = socket.setsockopt(XS::IDENTITY, identity)
+            rc.should == -1
+          end
+        end # context using option XS::IDENTITY
+
+
+        context "using option XS::SUBSCRIBE" do
+          if XS::SUB == socket_type
+            it "returns 0 for a SUB socket" do
+              rc = socket.setsockopt(XS::SUBSCRIBE, "topic.string")
+              rc.should == 0
+            end
+          else
+            it "returns -1 for non-SUB sockets" do
+              rc = socket.setsockopt(XS::SUBSCRIBE, "topic.string")
+              rc.should == -1
+            end
+          end
+        end # context using option XS::SUBSCRIBE
+
+
+        context "using option XS::UNSUBSCRIBE" do
+          if XS::SUB == socket_type
+            it "returns 0 given a topic string that was previously subscribed" do
+              socket.setsockopt XS::SUBSCRIBE, "topic.string"
+              rc = socket.setsockopt(XS::UNSUBSCRIBE, "topic.string")
+              rc.should == 0
+            end
+
+          else
+            it "returns -1 for non-SUB sockets" do
+              rc = socket.setsockopt(XS::UNSUBSCRIBE, "topic.string")
+              rc.should == -1
+            end
+          end
+        end # context using option XS::UNSUBSCRIBE
+
+
+        context "using option XS::AFFINITY" do
+          it "should set the affinity value given a positive value" do
+            affinity = 3
+            socket.setsockopt XS::AFFINITY, affinity
+            array = []
+            rc = socket.getsockopt(XS::AFFINITY, array)
+            rc.should == 0
+            array[0].should == affinity
+          end
+        end # context using option XS::AFFINITY
+
+
+        context "using option XS::RATE" do
+          it "should set the multicast send rate given a positive value" do
+            rate = 200
+            socket.setsockopt XS::RATE, rate
+            array = []
+            rc = socket.getsockopt(XS::RATE, array)
+            rc.should == 0
+            array[0].should == rate
+          end
+
+          it "returns -1 given a negative value" do
+            rate = -200
+            rc = socket.setsockopt XS::RATE, rate
+            rc.should == -1
+          end
+        end # context using option XS::RATE
+
+
+        context "using option XS::RECOVERY_IVL" do
+          it "should set the multicast recovery buffer measured in seconds given a positive value" do
+            rate = 200
+            socket.setsockopt XS::RECOVERY_IVL, rate
+            array = []
+            rc = socket.getsockopt(XS::RECOVERY_IVL, array)
+            rc.should == 0
+            array[0].should == rate
+          end
+
+          it "returns -1 given a negative value" do
+            rate = -200
+            rc = socket.setsockopt XS::RECOVERY_IVL, rate
+            rc.should == -1
+          end
+        end # context using option XS::RECOVERY_IVL
+
+
+        context "using option XS::SNDBUF" do
+          it "should set the OS send buffer given a positive value" do
+            size = 100
+            socket.setsockopt XS::SNDBUF, size
+            array = []
+            rc = socket.getsockopt(XS::SNDBUF, array)
+            rc.should == 0
+            array[0].should == size
+          end
+        end # context using option XS::SNDBUF
+
+
+        context "using option XS::RCVBUF" do
+          it "should set the OS receive buffer given a positive value" do
+            size = 100
+            socket.setsockopt XS::RCVBUF, size
+            array = []
+            rc = socket.getsockopt(XS::RCVBUF, array)
+            rc.should == 0
+            array[0].should == size
+          end
+        end # context using option XS::RCVBUF
+
+
+        context "using option XS::LINGER" do
+          it "should set the socket message linger option measured in milliseconds given a positive value" do
+            value = 200
+            socket.setsockopt XS::LINGER, value
+            array = []
+            rc = socket.getsockopt(XS::LINGER, array)
+            rc.should == 0
+            array[0].should == value
+          end
+
+          it "should set the socket message linger option to 0 for dropping packets" do
+            value = 0
+            socket.setsockopt XS::LINGER, value
+            array = []
+            rc = socket.getsockopt(XS::LINGER, array)
+            rc.should == 0
+            array[0].should == value
+          end
+
+          if (defined?(XS::XSUB) && XS::XSUB == socket_type) or
+             (defined?(XS::SUB) && XS::SUB == socket_type)
+            it "should default to a value of 0" do
+              value = 0
+              array = []
+              rc = socket.getsockopt(XS::LINGER, array)
+              rc.should == 0
+              array[0].should == value
+            end
+          else
+            it "should default to a value of -1" do
+              value = -1
+              array = []
+              rc = socket.getsockopt(XS::LINGER, array)
+              rc.should == 0
+              array[0].should == value
+            end
+          end
+        end # context using option XS::LINGER
+
+
+        context "using option XS::RECONNECT_IVL" do
+          it "should set the time interval for reconnecting disconnected sockets measured in milliseconds given a positive value" do
+            value = 200
+            socket.setsockopt XS::RECONNECT_IVL, value
+            array = []
+            rc = socket.getsockopt(XS::RECONNECT_IVL, array)
+            rc.should == 0
+            array[0].should == value
+          end
+
+          it "should default to a value of 100" do
+            value = 100
+            array = []
+            rc = socket.getsockopt(XS::RECONNECT_IVL, array)
+            rc.should == 0
+            array[0].should == value
+          end
+        end # context using option XS::RECONNECT_IVL
+
+
+        context "using option XS::BACKLOG" do
+          it "should set the maximum number of pending socket connections given a positive value" do
+            value = 200
+            socket.setsockopt XS::BACKLOG, value
+            array = []
+            rc = socket.getsockopt(XS::BACKLOG, array)
+            rc.should == 0
+            array[0].should == value
+          end
+
+          it "should default to a value of 100" do
+            value = 100
+            array = []
+            rc = socket.getsockopt(XS::BACKLOG, array)
+            rc.should == 0
+            array[0].should == value
+          end
+        end # context using option XS::BACKLOG
+      end # context #setsockopt
+
+
+      context "#getsockopt for a #{XS::SocketTypeNameMap[socket_type]} socket" do
+        before(:all) { @ctx = Context.new }
+        after(:all) { @ctx.terminate }
+
+        let(:socket) do
+          Socket.new @ctx.pointer, socket_type
+        end
+
+        after(:each) do
+          socket.close
+        end
+
+        if RUBY_PLATFORM =~ /linux|darwin/
+          # this spec doesn't work on Windows; hints welcome
+
+          context "using option XS::FD" do
+            it "should return an FD as a positive integer" do
+              array = []
+              rc = socket.getsockopt(XS::FD, array)
+              rc.should == 0
+              array[0].should be_a(Fixnum)
+            end
+
+            it "returns a valid FD that is accepted by the system poll() function" do
+              # Use FFI to wrap the C library function +poll+ so that we can execute it
+              # on the 0mq file descriptor. If it returns 0, then it succeeded and the FD
+              # is valid!
+              module LibSocket
+                extend FFI::Library
+                # figures out the correct libc for each platform including Windows
+                library = ffi_lib(FFI::Library::LIBC).first
+
+                find_type(:nfds_t) rescue typedef(:uint32, :nfds_t)
+
+                attach_function :poll, [:pointer, :nfds_t, :int], :int
+
+                class PollFD < FFI::Struct
+                  layout :fd,    :int,
+                  :events, :short,
+                  :revents, :short
+                end
+              end # module LibSocket
+
+              array = []
+              rc = socket.getsockopt(XS::FD, array)
+              rc.should be_zero
+              fd = array[0]
+
+              # setup the BSD poll_fd struct
+              pollfd = LibSocket::PollFD.new
+              pollfd[:fd] = fd
+              pollfd[:events] = 0
+              pollfd[:revents] = 0
+
+              rc = LibSocket.poll(pollfd, 1, 0)
+              rc.should be_zero
+            end
+          end
+
+        end # posix platform
+
+        context "using option XS::EVENTS" do
+          it "should return a mask of events as a Fixnum" do
+            array = []
+            rc = socket.getsockopt(XS::EVENTS, array)
+            rc.should == 0
+            array[0].should be_a(Fixnum)
+          end
+        end
+
+        context "using option XS::TYPE" do
+          it "should return the socket type" do
+            array = []
+            rc = socket.getsockopt(XS::TYPE, array)
+            rc.should == 0
+            array[0].should == socket_type
+          end
+        end
+      end # context #getsockopt
+
+    end # each socket_type
+
+
+    describe "Mapping socket EVENTS to POLLIN and POLLOUT" do
+      include APIHelper
+      
+      shared_examples_for "pubsub sockets where" do
+        it "SUB socket that received a message always has POLLIN set" do
+          events = []
+          rc = @sub.getsockopt(XS::EVENTS, events)
+          rc.should == 0
+          events[0].should == XS::POLLIN
+        end
+
+        it "PUB socket always has POLLOUT set" do
+          events = []
+          rc = @pub.getsockopt(XS::EVENTS, events)
+          rc.should == 0
+          events[0].should == XS::POLLOUT
+        end
+
+        it "PUB socket never has POLLIN set" do
+          events = []
+          rc = @pub.getsockopt(XS::EVENTS, events)
+          rc.should == 0
+          events[0].should_not == XS::POLLIN
+        end
+
+        it "SUB socket never has POLLOUT set" do
+          events = []
+          rc = @sub.getsockopt(XS::EVENTS, events)
+          rc.should == 0
+          events[0].should_not == XS::POLLOUT
+        end
+      end # shared example for pubsub
+      
+
+      context "when SUB connects and PUB binds" do
+
+        before(:each) do
+          @ctx = Context.new
+
+          @sub = @ctx.socket XS::SUB
+          rc = @sub.setsockopt XS::SUBSCRIBE, ''
+
+          @pub = @ctx.socket XS::PUB
+          port = bind_to_random_tcp_port(@pub)
+          rc = @sub.connect "tcp://127.0.0.1:#{port}"
+          sleep 0.5
+
+          rc = @pub.send_string('test')
+          sleep 0.2
+        end
+
+        it_behaves_like "pubsub sockets where"
+      end # context SUB binds PUB connects
+
+
+      after(:each) do
+        @sub.close
+        @pub.close
+        # must call close on *every* socket before calling terminate otherwise it blocks indefinitely
+        @ctx.terminate
+      end
+
+    end # describe 'events mapping to pollin and pollout'
+
+  end # describe Socket
+
+
+end # module XS

data/spec/spec_helper.rb

@@ -0,0 +1,57 @@
+# Execute 'rake spec' from the main directory to run all specs.
+
+require File.expand_path(
+File.join(File.dirname(__FILE__), %w[.. lib ffi-rxs]))
+
+Thread.abort_on_exception = true
+
+module APIHelper
+  def stub_libxs
+    @err_str_mock = mock("error string")
+
+    LibXS.stub!(
+    :xs_init => 0,
+    :xs_errno => 0,
+    :xs_sterror => @err_str_mock
+    )
+  end
+
+  # generate a random port between 10_000 and 65534
+  def random_port
+    rand(55534) + 10_000
+  end
+
+  def bind_to_random_tcp_port socket, max_tries = 500
+    tries = 0
+    rc = -1
+
+    while !XS::Util.resultcode_ok?(rc) && tries < max_tries
+      tries += 1
+      random = random_port
+      rc = socket.bind(local_transport_string(random))
+    end
+
+    random
+  end
+
+  def connect_to_random_tcp_port socket, max_tries = 500
+    tries = 0
+    rc = -1
+
+    while !XS::Util.resultcode_ok?(rc) && tries < max_tries
+      tries += 1
+      random = random_port
+      rc = socket.connect(local_transport_string(random))
+    end
+
+    random
+  end
+  
+  def local_transport_string(port)
+    "tcp://127.0.0.1:#{port}"
+  end
+
+  def assert_ok(rc)
+    raise "Failed with rc [#{rc}] and errno [#{XS::Util.errno}], msg [#{XS::Util.error_string}]! #{caller(0)}" unless rc >= 0
+  end
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: ffi-rxs
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Chris Duncan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: &83395810 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *83395810
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &83413290 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :development
+  prerelease: false
+  version_requirements: *83413290
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &83412730 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *83412730
+description: ! 'This gem wraps the Crossroads I/O networking library using the ruby
+  FFI (foreign
+
+  function interface). It''s a pure ruby wrapper so this gem can be loaded
+
+  and run by any ruby runtime that supports FFI. That''s all of them:
+
+  MRI 1.9.x, Rubinius and JRuby.'
+email:
+- celldee@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- AUTHORS.txt
+- Gemfile
+- README.rdoc
+- Rakefile
+- ext/README
+- ffi-rxs.gemspec
+- lib/ffi-rxs.rb
+- lib/ffi-rxs/constants.rb
+- lib/ffi-rxs/constants.rb~
+- lib/ffi-rxs/context.rb
+- lib/ffi-rxs/context.rb~
+- lib/ffi-rxs/device.rb~
+- lib/ffi-rxs/exceptions.rb
+- lib/ffi-rxs/exceptions.rb~
+- lib/ffi-rxs/libc.rb
+- lib/ffi-rxs/libc.rb~
+- lib/ffi-rxs/libxs.rb
+- lib/ffi-rxs/libxs.rb~
+- lib/ffi-rxs/message.rb
+- lib/ffi-rxs/message.rb~
+- lib/ffi-rxs/poll.rb
+- lib/ffi-rxs/poll.rb~
+- lib/ffi-rxs/poll_items.rb
+- lib/ffi-rxs/poll_items.rb~
+- lib/ffi-rxs/socket.rb
+- lib/ffi-rxs/socket.rb~
+- lib/ffi-rxs/util.rb
+- lib/ffi-rxs/util.rb~
+- lib/ffi-rxs/version.rb
+- lib/ffi-rxs/version.rb~
+- spec/context_spec.rb
+- spec/message_spec.rb
+- spec/multipart_spec.rb
+- spec/nonblocking_recv_spec.rb
+- spec/poll_spec.rb
+- spec/pushpull_spec.rb
+- spec/reqrep_spec.rb
+- spec/socket_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/celldee/ffi-rxs
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: This gem wraps the Crossroads I/O networking library using Ruby FFI (foreign
+  function interface).
+test_files: []