nio4r 0.2.2 → 0.3.0

data/spec/nio/selector_spec.rb

@@ -6,11 +6,17 @@ require 'spec_helper'
 TIMEOUT_PRECISION = 0.1
 
 describe NIO::Selector do
-  it "monitors IO objects" do
-    pipe, _ = IO.pipe
+  context "register" do
+    it "registers IO objects" do
+      pipe, _ = IO.pipe
+
+      monitor = subject.register(pipe, :r)
+      monitor.should_not be_closed
+    end
 
-    monitor = subject.register(pipe, :r)
-    monitor.should_not be_closed
+    it "raises TypeError if asked to register non-IO objects" do
+      expect { subject.register(42, :r) }.to raise_exception TypeError
+    end
   end
 
   it "knows which IO objects are registered" do
@@ -30,22 +36,31 @@ describe NIO::Selector do
     monitor.should be_closed
   end
 
-  it "waits for a timeout when selecting" do
-    reader, writer = IO.pipe
-    monitor = subject.register(reader, :r)
+  context "timeouts" do
+    it "waits for a timeout when selecting" do
+      reader, writer = IO.pipe
+      monitor = subject.register(reader, :r)
 
-    payload = "hi there"
-    writer << payload
+      payload = "hi there"
+      writer << payload
 
-    timeout = 0.5
-    started_at = Time.now
-    subject.select(timeout).should include monitor
-    (Time.now - started_at).should be_within(TIMEOUT_PRECISION).of(0)
-    reader.read_nonblock(payload.size)
+      timeout = 0.5
+      started_at = Time.now
+      subject.select(timeout).should include monitor
+      (Time.now - started_at).should be_within(TIMEOUT_PRECISION).of(0)
+      reader.read_nonblock(payload.size)
 
-    started_at = Time.now
-    subject.select(timeout).should be_nil
-    (Time.now - started_at).should be_within(TIMEOUT_PRECISION).of(timeout)
+      started_at = Time.now
+      subject.select(timeout).should be_nil
+      (Time.now - started_at).should be_within(TIMEOUT_PRECISION).of(timeout)
+    end
+
+    it "raises ArgumentError if given a negative timeout" do
+      reader, _ = IO.pipe
+      subject.register(reader, :r)
+
+      expect { subject.select(-1) }.to raise_exception(ArgumentError)
+    end
   end
 
   context "wakeup" do
@@ -74,6 +89,45 @@ describe NIO::Selector do
     end
   end
 
+  context "select" do
+    it "selects IO objects" do
+      readable, writer = IO.pipe
+      writer << "ohai"
+
+      unreadable, _ = IO.pipe
+
+      readable_monitor   = subject.register(readable, :r)
+      unreadable_monitor = subject.register(unreadable, :r)
+
+      selected = subject.select(0)
+      selected.size.should == 1
+      selected.should include(readable_monitor)
+      selected.should_not include(unreadable_monitor)
+    end
+
+    it "iterates across selected objects with a block" do
+      readable1, writer = IO.pipe
+      writer << "ohai"
+
+      readable2, writer = IO.pipe
+      writer << "ohai"
+
+      unreadable, _ = IO.pipe
+
+      monitor1 = subject.register(readable1, :r)
+      monitor2 = subject.register(readable2, :r)
+      monitor3 = subject.register(unreadable, :r)
+
+      readables = []
+      result = subject.select { |monitor| readables << monitor }
+      result.should == 2
+
+      readables.should include(monitor1)
+      readables.should include(monitor2)
+      readables.should_not include(monitor3)
+    end
+  end
+
   context "select_each" do
     it "iterates across ready selectables" do
       readable1, writer = IO.pipe
@@ -117,160 +171,4 @@ describe NIO::Selector do
     subject.close
     subject.should be_closed
   end
-
-  context "selectables" do
-    shared_context "an NIO selectable" do
-      it "selects for read readiness" do
-        waiting_monitor = subject.register(unreadable_subject, :r)
-        ready_monitor   = subject.register(readable_subject, :r)
-
-        ready_monitors = subject.select
-        ready_monitors.should include ready_monitor
-        ready_monitors.should_not include waiting_monitor
-      end
-
-      it "selects for write readiness" do
-        waiting_monitor = subject.register(unwritable_subject, :w)
-        ready_monitor   = subject.register(writable_subject, :w)
-
-        ready_monitors = subject.select(0.1)
-
-        ready_monitors.should include ready_monitor
-        ready_monitors.should_not include waiting_monitor
-      end
-    end
-
-    context "IO.pipe" do
-      let :readable_subject do
-        pipe, peer = IO.pipe
-        peer << "data"
-        pipe
-      end
-
-      let :unreadable_subject do
-        pipe, _ = IO.pipe
-        pipe
-      end
-
-      let :writable_subject do
-        _, pipe = IO.pipe
-        pipe
-      end
-
-      let :unwritable_subject do
-        reader, pipe = IO.pipe
-
-        begin
-          pipe.write_nonblock "JUNK IN THE TUBES"
-          _, writers = select [], [pipe], [], 0
-        rescue Errno::EPIPE
-          break
-        end while writers and writers.include? pipe
-
-        pipe
-      end
-
-      it_behaves_like "an NIO selectable"
-    end
-
-    context TCPSocket do
-      let(:tcp_port) { 12345 }
-
-      let :readable_subject do
-        server = TCPServer.new("localhost", tcp_port)
-        sock = TCPSocket.open("localhost", tcp_port)
-        peer = server.accept
-        peer << "data"
-        sock
-      end
-
-      let :unreadable_subject do
-        if defined?(JRUBY_VERSION) and ENV['TRAVIS']
-          pending "This is sporadically showing up readable on JRuby in CI"
-        else
-          TCPServer.new("localhost", tcp_port + 1)
-          TCPSocket.open("localhost", tcp_port + 1)
-        end
-      end
-
-      let :writable_subject do
-        TCPServer.new("localhost", tcp_port + 2)
-        TCPSocket.open("localhost", tcp_port + 2)
-      end
-
-      let :unwritable_subject do
-        server = TCPServer.new("localhost", tcp_port + 3)
-        sock = TCPSocket.open("localhost", tcp_port + 3)
-        peer = server.accept
-
-        begin
-          sock.write_nonblock "JUNK IN THE TUBES"
-          _, writers = select [], [sock], [], 0
-        end while writers and writers.include? sock
-
-        sock
-      end
-
-      it_behaves_like "an NIO selectable"
-    end
-
-    context UDPSocket do
-      let(:udp_port) { 23456 }
-
-      let :readable_subject do
-        sock = UDPSocket.new
-        sock.bind('localhost', udp_port)
-
-        peer = UDPSocket.new
-        peer.send("hi there", 0, 'localhost', udp_port)
-
-        sock
-      end
-
-      let :unreadable_subject do
-        sock = UDPSocket.new
-        sock.bind('localhost', udp_port + 1)
-        sock
-      end
-
-      let :writable_subject do
-        pending "come up with a writable UDPSocket example"
-      end
-
-      let :unwritable_subject do
-        pending "come up with a UDPSocket that's blocked on writing"
-      end
-
-      it_behaves_like "an NIO selectable"
-    end
-  end
-
-  context "acceptables" do
-    shared_context "an NIO acceptable" do
-      it "selects for read readiness" do
-        waiting_monitor = subject.register(unacceptable_subject, :r)
-        ready_monitor   = subject.register(acceptable_subject, :r)
-
-        ready_monitors = subject.select
-        ready_monitors.should include ready_monitor
-        ready_monitors.should_not include waiting_monitor
-      end
-    end
-
-    context TCPServer do
-      let(:tcp_port) { 23456 }
-
-      let :acceptable_subject do
-        server = TCPServer.new("localhost", tcp_port)
-        TCPSocket.open("localhost", tcp_port)
-        server
-      end
-
-      let :unacceptable_subject do
-        TCPServer.new("localhost", tcp_port + 1)
-      end
-
-      it_behaves_like "an NIO acceptable"
-    end
-  end
 end

data/tasks/extension.rake

@@ -1,9 +1,10 @@
-require 'rake/extensiontask'
-
-if defined?(JRUBY_VERSION)
-  # Don't build the native extension on JRuby since it uses native Java NIO
-  task :compile
+if defined? JRUBY_VERSION
+  require 'rake/javaextensiontask'
+  Rake::JavaExtensionTask.new('nio4r_ext') do |ext|
+    ext.ext_dir = 'ext/nio4r'
+  end
 else
+  require 'rake/extensiontask'
   Rake::ExtensionTask.new('nio4r_ext') do |ext|
     ext.ext_dir = 'ext/nio4r'
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nio4r
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,22 +9,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-08 00:00:00.000000000 Z
+date: 2012-02-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
-  requirement: &70252075568080 !ruby/object:Gem::Requirement
+  requirement: &70285234600680 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.7.9
+        version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70252075568080
+  version_requirements: *70285234600680
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70252075567520 !ruby/object:Gem::Requirement
+  requirement: &70285234600040 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,18 +32,18 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70252075567520
+  version_requirements: *70285234600040
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70252071622900 !ruby/object:Gem::Requirement
+  requirement: &70285234599480 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 2.7.0
+        version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70252071622900
+  version_requirements: *70285234599480
 description: New IO for Ruby
 email:
 - tony.arcieri@gmail.com
@@ -81,15 +81,16 @@ files:
 - ext/nio4r/monitor.c
 - ext/nio4r/nio4r.h
 - ext/nio4r/nio4r_ext.c
+- ext/nio4r/org/nio4r/Nio4r.java
 - ext/nio4r/selector.c
 - lib/nio.rb
-- lib/nio/jruby/monitor.rb
-- lib/nio/jruby/selector.rb
 - lib/nio/monitor.rb
 - lib/nio/selector.rb
 - lib/nio/version.rb
 - nio4r.gemspec
+- spec/nio/acceptables_spec.rb
 - spec/nio/monitor_spec.rb
+- spec/nio/selectables_spec.rb
 - spec/nio/selector_spec.rb
 - spec/spec_helper.rb
 - tasks/extension.rake
@@ -119,7 +120,9 @@ signing_key:
 specification_version: 3
 summary: NIO provides a high performance selector API for monitoring IO objects
 test_files:
+- spec/nio/acceptables_spec.rb
 - spec/nio/monitor_spec.rb
+- spec/nio/selectables_spec.rb
 - spec/nio/selector_spec.rb
 - spec/spec_helper.rb
 has_rdoc: 

data/lib/nio/jruby/monitor.rb

@@ -1,42 +0,0 @@
-module NIO
-  # Monitors watch Channels for specific events
-  class Monitor
-    attr_accessor :value, :io
-
-    # :nodoc
-    def initialize(io, selection_key)
-      @io, @key = io, selection_key
-      selection_key.attach self
-      @closed = false
-    end
-
-    # Obtain the interests for this monitor
-    def interests
-      Selector.iops2sym @key.interestOps
-    end
-
-    # What is the IO object ready for?
-    def readiness
-      Selector.iops2sym @key.readyOps
-    end
-
-    # Is the IO object readable?
-    def readable?
-      readiness == :r || readiness == :rw
-    end
-
-    # Is the IO object writable?
-    def writable?
-      readiness == :w || readiness == :rw
-    end
-    alias_method :writeable?, :writable?
-
-    # Is this monitor closed?
-    def closed?; @closed; end
-
-    # Deactivate this monitor
-    def close
-      @closed = true
-    end
-  end
-end

data/lib/nio/jruby/selector.rb

@@ -1,136 +0,0 @@
-module NIO
-  # Selectors monitor IO objects for events of interest
-  class Selector
-    java_import "java.nio.channels.Selector"
-    java_import "java.nio.channels.SelectionKey"
-
-    # Convert nio4r interest symbols to Java NIO interest ops
-    def self.sym2iops(interest, channel)
-      case interest
-      when :r
-        if channel.validOps & SelectionKey::OP_ACCEPT != 0
-          SelectionKey::OP_ACCEPT
-        else
-          SelectionKey::OP_READ
-        end
-      when :w
-        if channel.respond_to? :connected? and not channel.connected?
-          SelectionKey::OP_CONNECT
-        else
-          SelectionKey::OP_WRITE
-        end
-      when :rw
-        super(:r, channel) | super(:w, channel)
-      else raise ArgumentError, "invalid interest type: #{interest}"
-      end
-    end
-
-    # Convert Java NIO interest ops to the corresponding Ruby symbols
-    def self.iops2sym(interest_ops)
-      case interest_ops
-      when SelectionKey::OP_READ, SelectionKey::OP_ACCEPT
-        :r
-      when SelectionKey::OP_WRITE, SelectionKey::OP_CONNECT
-        :w
-      when SelectionKey::OP_READ | SelectionKey::OP_WRITE
-        :rw
-      when 0 then nil
-      else raise ArgumentError, "unknown interest op combination: 0x#{interest_ops.to_s(16)}"
-      end
-    end
-
-    # Create a new NIO::Selector
-    def initialize
-      @java_selector = Selector.open
-      @select_lock = Mutex.new
-    end
-
-    # Register interest in an IO object with the selector for the given types
-    # of events. Valid event types for interest are:
-    # * :r - is the IO readable?
-    # * :w - is the IO writeable?
-    # * :rw - is the IO either readable or writeable?
-    def register(io, interest)
-      java_channel = io.to_channel
-      java_channel.configureBlocking(false)
-      interest_ops = self.class.sym2iops(interest, java_channel)
-
-      begin
-        selector_key = java_channel.register @java_selector, interest_ops
-      rescue NativeException => ex
-        case ex.cause
-        when java.lang.IllegalArgumentException
-          raise ArgumentError, "invalid interest type for #{java_channel}: #{interest}"
-        else raise
-        end
-      end
-
-      NIO::Monitor.new(io, selector_key)
-    end
-
-    # Deregister the given IO object from the selector
-    def deregister(io)
-      key = io.to_channel.keyFor(@java_selector)
-      return unless key
-
-      monitor = key.attachment
-      monitor.close
-      monitor
-    end
-
-    # Is the given IO object registered with the selector?
-    def registered?(io)
-      key = io.to_channel.keyFor(@java_selector)
-      return unless key
-      !key.attachment.closed?
-    end
-
-    # Select which monitors are ready
-    def select(timeout = nil)
-      selected = []
-      ready = select_each(timeout) { |monitor| selected << monitor }
-      return unless ready
-
-      selected
-    end
-
-    # Iterate across all selectable monitors
-    def select_each(timeout = nil)
-      @select_lock.synchronize do
-        if timeout == 0
-          # The Java NIO API thinks zero means you want to BLOCK FOREVER o_O
-          # How about we don't block at all instead?
-          ready = @java_selector.selectNow
-        elsif timeout
-          ready = @java_selector.select(timeout * 1000)
-        else
-          ready = @java_selector.select
-        end
-
-        return unless ready > 0 # timeout or wakeup
-
-        @java_selector.selectedKeys.each { |key| yield key.attachment }
-        @java_selector.selectedKeys.clear
-
-        ready
-      end
-    end
-
-    # Wake up the other thread that's currently blocking on this selector
-    def wakeup
-      raise IOError, "selector is closed" if closed?
-      @java_selector.wakeup
-      nil
-    end
-
-    # Close this selector
-    def close
-      @java_selector.close
-    end
-
-    # Is this selector closed?
-    def closed?
-      !@java_selector.isOpen
-    end
-  end
-end