nio4r 0.2.2-java → 0.3.0-java

data/ext/nio4r/selector.c

@@ -209,9 +209,9 @@ static VALUE NIO_Selector_register_synchronized(VALUE *args)
         rb_raise(rb_eArgError, "this IO is already registered with selector");
 
     /* Create a new NIO::Monitor */
-    monitor_args[0] = self;
-    monitor_args[1] = io;
-    monitor_args[2] = interests;
+    monitor_args[0] = io;
+    monitor_args[1] = interests;
+    monitor_args[2] = self;
 
     monitor = rb_class_new_instance(3, monitor_args, cNIO_Monitor);
     rb_hash_aset(selectables, io, monitor);
@@ -239,7 +239,7 @@ static VALUE NIO_Selector_deregister_synchronized(VALUE *args)
     monitor = rb_hash_delete(selectables, io);
 
     if(monitor != Qnil) {
-        rb_funcall(monitor, rb_intern("close"), 0, 0);
+        rb_funcall(monitor, rb_intern("close"), 1, Qfalse);
     }
 
     return monitor;
@@ -262,6 +262,10 @@ static VALUE NIO_Selector_select(int argc, VALUE *argv, VALUE self)
 
     rb_scan_args(argc, argv, "01", &timeout);
 
+    if(timeout != Qnil && NUM2DBL(timeout) < 0) {
+        rb_raise(rb_eArgError, "time interval must be positive");
+    }
+
     args[0] = self;
     args[1] = timeout;
 
@@ -280,6 +284,10 @@ static VALUE NIO_Selector_select_each(int argc, VALUE *argv, VALUE self)
 
     rb_scan_args(argc, argv, "01", &timeout);
 
+    if(timeout != Qnil && NUM2DBL(timeout) < 0) {
+        rb_raise(rb_eArgError, "time interval must be positive");
+    }
+
     args[0] = self;
     args[1] = timeout;
 
@@ -290,12 +298,21 @@ static VALUE NIO_Selector_select_each(int argc, VALUE *argv, VALUE self)
 static VALUE NIO_Selector_select_synchronized(VALUE *args)
 {
     struct NIO_Selector *selector;
-    int ready = NIO_Selector_fill_ready_buffer(args);
+    int i, ready = NIO_Selector_fill_ready_buffer(args);
 
     Data_Get_Struct(args[0], struct NIO_Selector, selector);
 
     if(ready > 0) {
-        return rb_ary_new4(ready, selector->ready_buffer);
+        if(rb_block_given_p()) {
+            for(i = 0; i < ready; i++) {
+                rb_yield(selector->ready_buffer[i]);
+            }
+
+            return INT2NUM(ready);
+        } else {
+            /* new4 memcpys the ready buffer */
+            return rb_ary_new4(ready, selector->ready_buffer);
+        }
     } else {
         return Qnil;
     }
@@ -335,7 +352,8 @@ static int NIO_Selector_fill_ready_buffer(VALUE *args)
 #if defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_ALONE)
     /* Implement the optional timeout (if any) as a ev_timer */
     if(timeout != Qnil) {
-        selector->timer.repeat = NUM2DBL(timeout);
+        /* It seems libev is not a fan of timers being zero, so fudge a little */
+        selector->timer.repeat = NUM2DBL(timeout) + 0.0001;
         ev_timer_again(selector->ev_loop, &selector->timer);
     } else {
         ev_timer_stop(selector->ev_loop, &selector->timer);
@@ -455,7 +473,17 @@ static void NIO_Selector_wakeup_callback(struct ev_loop *ev_loop, struct ev_io *
 
 /* This gets called from individual monitors. We must be careful here because
    the GIL isn't held, so we must rely only on standard C and can't touch
-   anything Ruby-related */
+   anything Ruby-related.
+
+   It's scary because there's a VALUE here, and VALUEs are a Ruby thing,
+   however we're not going to dereference that VALUE or attempt to do anything
+   with it. We just treat it as completely opaque until we have the GIL back.
+
+   In order for this function to even get called, the monitor the VALUE points to
+   must be attached to this Selector, and if it's attached to this Selector
+   then we hold a reference to it in the @selectables instance variable, so
+   there's no danger of this monitor getting garbage collected before we have
+   the GIL back as we hold a reference. */
 void NIO_Selector_handle_event(struct NIO_Selector *selector, VALUE monitor, int revents)
 {
     /* Grow the ready buffer if it's too small */

data/lib/nio.rb

@@ -15,16 +15,13 @@ if ENV["NIO4R_PURE"]
   require 'nio/selector'
   NIO::ENGINE = 'select'
 else
+  require 'nio4r_ext'
+
   if defined?(JRUBY_VERSION)
     require 'java'
-    require 'nio/jruby/monitor'
-    require 'nio/jruby/selector'
+    org.nio4r.Nio4r.new.load(JRuby.runtime, false)
     NIO::ENGINE = 'java'
   else
-    require 'nio4r_ext'
     NIO::ENGINE = 'libev'
   end
-end
-
-# TIMTOWTDI!!!
-Nio = NIO
+end

data/lib/nio/monitor.rb

@@ -1,12 +1,22 @@
 module NIO
   # Monitors watch IO objects for specific events
   class Monitor
-    attr_reader :io, :interests
+    attr_reader :io, :interests, :selector
     attr_accessor :value, :readiness
 
     # :nodoc
-    def initialize(io, interests)
-      @io, @interests = io, interests
+    def initialize(io, interests, selector)
+      unless io.is_a?(IO)
+        if IO.respond_to? :try_convert
+          io = IO.try_convert(io)
+        elsif io.respond_to? :to_io
+          io = io.to_io
+        end
+
+        raise TypeError, "can't convert #{io.class} into IO" unless io.is_a? IO
+      end
+
+      @io, @interests, @selector = io, interests, selector
       @closed = false
     end
 
@@ -25,8 +35,9 @@ module NIO
     def closed?; @closed; end
 
     # Deactivate this monitor
-    def close
+    def close(deregister = true)
       @closed = true
+      @selector.deregister(io) if deregister
     end
   end
 end

data/lib/nio/selector.rb

@@ -20,7 +20,7 @@ module NIO
       @lock.synchronize do
         raise ArgumentError, "this IO is already registered with the selector" if @selectables[io]
 
-        monitor = Monitor.new(io, interest)
+        monitor = Monitor.new(io, interest, self)
         @selectables[io] = monitor
 
         monitor
@@ -31,7 +31,7 @@ module NIO
     def deregister(io)
       @lock.synchronize do
         monitor = @selectables.delete io
-        monitor.close if monitor
+        monitor.close(false) if monitor and not monitor.closed?
         monitor
       end
     end
@@ -54,7 +54,12 @@ module NIO
         ready_readers, ready_writers = Kernel.select readers, writers, [], timeout
         return unless ready_readers # timeout or wakeup
 
-        results = []
+        if block_given?
+          result = 0
+        else
+          result = []
+        end
+
         ready_readers.each do |io|
           if io == @wakeup
             # Clear all wakeup signals we've received by reading them
@@ -71,7 +76,13 @@ module NIO
           else
             monitor = @selectables[io]
             monitor.readiness = :r
-            results << monitor
+
+            if block_given?
+              yield monitor
+              result += 1
+            else
+              result << monitor
+            end
           end
         end
 
@@ -82,11 +93,17 @@ module NIO
           ios.each do |io|
             monitor = @selectables[io]
             monitor.readiness = readiness
-            results << monitor
+
+            if block_given?
+              yield monitor
+              result += 1
+            else
+              result << monitor
+            end
           end
         end
 
-        results
+        result
       end
     end
 

data/lib/nio/version.rb

@@ -1,3 +1,3 @@
 module NIO
-  VERSION = "0.2.2"
+  VERSION = "0.3.0"
 end

data/nio4r.gemspec

@@ -15,8 +15,9 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = NIO::VERSION
 #  gem.extensions    = ["ext/nio4r/extconf.rb"]
-  gem.platform = 'java'
-  gem.add_development_dependency "rake-compiler", "~> 0.7.9"
+  gem.platform      = 'java'
+
+  gem.add_development_dependency "rake-compiler"
   gem.add_development_dependency "rake"
-  gem.add_development_dependency "rspec", "~> 2.7.0"
+  gem.add_development_dependency "rspec"
 end

data/spec/nio/acceptables_spec.rb

@@ -0,0 +1,30 @@
+describe "NIO acceptables" do
+  shared_context "an NIO acceptable" do
+    let(:selector) { NIO::Selector.new }
+
+    it "selects for read readiness" do
+      waiting_monitor = selector.register(unacceptable_subject, :r)
+      ready_monitor   = selector.register(acceptable_subject, :r)
+
+      ready_monitors = selector.select
+      ready_monitors.should include ready_monitor
+      ready_monitors.should_not include waiting_monitor
+    end
+  end
+
+  describe 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

data/spec/nio/monitor_spec.rb

@@ -1,21 +1,26 @@
 require 'spec_helper'
 
 describe NIO::Monitor do
-  let :readable do
-    reader, writer = IO.pipe
-    writer << "have some data"
-    reader
-  end
+  let(:pipes) { IO.pipe }
+  let(:reader) { pipes.first }
+  let(:writer) { pipes.last }
+  let(:selector) { NIO::Selector.new }
+
+  subject    { selector.register(reader, :rw) }
+  let(:peer) { selector.register(writer, :rw) }
+  after      { selector.close }
 
-  let :selector do
-    NIO::Selector.new
+  it "knows its interests" do
+    subject.interests.should == :rw
+    peer.interests.should == :rw
   end
 
-  # Monitors are created by registering IO objects or channels with a selector
-  subject { selector.register(readable, :r) }
+  it "knows its IO object" do
+    subject.io.should == reader
+  end
 
-  it "knows its interests" do
-    subject.interests.should == :r
+  it "knows its selector" do
+    subject.selector.should == selector
   end
 
   it "stores arbitrary values" do
@@ -23,24 +28,34 @@ describe NIO::Monitor do
     subject.value.should == 42
   end
 
-  it "knows what IO objects are ready for" do
-    # Perhaps let bindings are just confusing me but they're not producing
-    # what I want. Manually doing the setup here does
-    # FIXME: Hey RSpec wizards! Fix this!
-    reader, writer = IO.pipe
+  it "knows what operations IO objects are ready for" do
+    # For whatever odd reason this breaks unless we eagerly evaluate subject
+    reader_monitor, writer_monitor = subject, peer
+
+    selected = selector.select(0)
+    selected.should_not include(reader_monitor)
+    selected.should include(writer_monitor)
+
+    writer_monitor.readiness.should == :w
+    writer_monitor.should_not be_readable
+    writer_monitor.should be_writable
+
     writer << "loldata"
-    selector = NIO::Selector.new
-    subject = selector.register(reader, :r)
 
-    # Here's where the spec really begins
-    selector.select(1).should include(subject)
-    subject.readiness.should == :r
-    subject.should be_readable
+    selected = selector.select(0)
+    selected.should include(reader_monitor)
+
+    reader_monitor.readiness.should == :r
+    reader_monitor.should be_readable
+    reader_monitor.should_not be_writable
   end
 
   it "closes" do
     subject.should_not be_closed
+    selector.registered?(reader).should be_true
+
     subject.close
     subject.should be_closed
+    selector.registered?(reader).should be_false
   end
 end

data/spec/nio/selectables_spec.rb

@@ -0,0 +1,178 @@
+describe "NIO selectables" do
+  let(:selector) { NIO::Selector.new }
+
+  shared_context "an NIO selectable" do
+    it "selects readable objects" do
+      monitor = selector.register(readable_subject, :r)
+      selector.select(0).should include monitor
+    end
+
+    it "does not select unreadable objects" do
+      monitor = selector.register(unreadable_subject, :r)
+      selector.select(0).should be_nil
+    end
+
+    it "selects writable objects" do
+      monitor = selector.register(writable_subject, :w)
+      selector.select(0).should include monitor
+    end
+
+    it "does not select unwritable objects" do
+      monitor = selector.register(unwritable_subject, :w)
+      selector.select(0).should be_nil
+    end
+  end
+
+  shared_context "an NIO selectable stream" do
+    let(:stream) { pair.first }
+    let(:peer)   { pair.last }
+
+    it "selects readable when the other end closes" do
+      monitor = selector.register(stream, :r)
+      selector.select(0).should be_nil
+
+      peer.close
+      selector.select(0).should include monitor
+    end
+  end
+
+  describe "IO.pipe" do
+    let(:pair) { IO.pipe }
+
+    let :unreadable_subject do pair.first end
+    let :readable_subject do
+      pipe, peer = pair
+      peer << "data"
+      pipe
+    end
+
+    let :writable_subject do pair.last 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"
+    it_behaves_like "an NIO selectable stream"
+  end
+
+  describe 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
+      TCPServer.new("localhost", tcp_port + 1)
+      sock = TCPSocket.new("localhost", tcp_port + 1)
+
+      # Sanity check to make sure we actually produced an unreadable socket
+      if select([sock], [], [], 0)
+        pending "Failed to produce an unreadable socket"
+      end
+
+      sock
+    end
+
+    let :writable_subject do
+      TCPServer.new("localhost", tcp_port + 2)
+      TCPSocket.new("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 "X" * 1024
+        _, writers = select [], [sock], [], 0
+      end while writers and writers.include? sock
+
+      # I think the kernel might manage to drain its buffer a bit even after
+      # the socket first goes unwritable. Attempt to sleep past this and then
+      # attempt to write again
+      sleep 0.1
+
+      # Once more for good measure!
+      begin
+        sock.write_nonblock "X" * 1024
+      rescue Errno::EWOULDBLOCK
+      end
+
+      # Sanity check to make sure we actually produced an unwritable socket
+      if select([], [sock], [], 0)
+        pending "Failed to produce an unwritable socket"
+      end
+
+      sock
+    end
+
+    let :pair do
+      server = TCPServer.new("localhost", tcp_port + 4)
+      client = TCPSocket.open("localhost", tcp_port + 4)
+      [client, server.accept]
+    end
+
+    it_behaves_like "an NIO selectable"
+    it_behaves_like "an NIO selectable stream"
+
+    it "selects writable when connected" do
+      server = TCPServer.new('127.0.0.1', tcp_port + 5)
+
+      client = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+      monitor = selector.register(client, :w)
+
+      expect do
+        client.connect_nonblock Socket.sockaddr_in(tcp_port + 5, '127.0.0.1')
+      end.to raise_exception Errno::EINPROGRESS
+
+      selector.select(0).should include monitor
+      result = client.getsockopt(::Socket::SOL_SOCKET, ::Socket::SO_ERROR)
+      result.unpack('i').first.should be_zero
+    end
+  end
+
+  describe 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