nio4r 0.0.1

data/lib/nio.rb

@@ -0,0 +1,30 @@
+require 'thread'
+require 'nio/version'
+
+# New I/O for Ruby
+module NIO
+  # NIO implementation, one of the following (as a string):
+  # * select: in pure Ruby using Kernel.select
+  # * libev: as a C extension using libev
+  # * java: using Java NIO
+  def self.engine; ENGINE end
+end
+
+if ENV["NIO4R_PURE"]
+  require 'nio/monitor'
+  require 'nio/selector'
+  NIO::ENGINE = 'select'
+else
+  if defined?(JRUBY_VERSION)
+    require 'java'
+    require 'nio/jruby/monitor'
+    require 'nio/jruby/selector'
+    NIO::ENGINE = 'java'
+  else
+    require 'nio4r_ext'
+    NIO::ENGINE = 'libev'
+  end
+end
+
+# TIMTOWTDI!!!
+Nio = NIO

data/lib/nio/jruby/monitor.rb

@@ -0,0 +1,26 @@
+module NIO
+  # Monitors watch Channels for specific events
+  class Monitor
+    attr_accessor :value
+
+    # :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
+
+    # Is this monitor closed?
+    def closed?; @closed; end
+
+    # Deactivate this monitor
+    def close
+      @closed = true
+    end
+  end
+end

data/lib/nio/jruby/selector.rb

@@ -0,0 +1,110 @@
+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)
+      case interest
+      when :r
+        interest = SelectionKey::OP_READ
+      when :w
+        interest = SelectionKey::OP_WRITE
+      when :rw
+        interest = SelectionKey::OP_READ | SelectionKey::OP_WRITE
+      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
+        :r
+      when SelectionKey::OP_WRITE
+        :w
+      when SelectionKey::OP_READ | SelectionKey::OP_WRITE
+        :rw
+      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)
+
+      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 #{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)
+      @select_lock.synchronize do
+        if timeout
+          ready = @java_selector.select(timeout * 1000)
+        else
+          ready = @java_selector.select
+        end
+
+        return unless ready > 0 # timeout or wakeup
+        @java_selector.selectedKeys.map { |key| key.attachment }
+      end
+    end
+
+    # Wake up the other thread that's currently blocking on this selector
+    def wakeup
+      @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

data/lib/nio/monitor.rb

@@ -0,0 +1,21 @@
+module NIO
+  # Monitors watch IO objects for specific events
+  class Monitor
+    attr_reader :io, :interests
+    attr_accessor :value
+
+    # :nodoc
+    def initialize(io, interests)
+      @io, @interests = io, interests
+      @closed = false
+    end
+
+    # Is this monitor closed?
+    def closed?; @closed; end
+
+    # Deactivate this monitor
+    def close
+      @closed = true
+    end
+  end
+end

data/lib/nio/selector.rb

@@ -0,0 +1,101 @@
+module NIO
+  # Selectors monitor IO objects for events of interest
+  class Selector
+    # Create a new NIO::Selector
+    def initialize
+      @selectables = {}
+      @lock = Mutex.new
+
+      # Other threads can wake up a selector
+      @wakeup, @waker = IO.pipe
+      @closed = false
+    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)
+      @lock.synchronize do
+        raise ArgumentError, "this IO is already registered with the selector" if @selectables[io]
+
+        monitor = Monitor.new(io, interest)
+        @selectables[io] = monitor
+
+        monitor
+      end
+    end
+
+    # Deregister the given IO object from the selector
+    def deregister(io)
+      @lock.synchronize do
+        monitor = @selectables.delete io
+        monitor.close if monitor
+        monitor
+      end
+    end
+
+    # Is the given IO object registered with the selector?
+    def registered?(io)
+      @lock.synchronize { @selectables.has_key? io }
+    end
+
+    # Select which monitors are ready
+    def select(timeout = nil)
+      @lock.synchronize do
+        readers, writers = [@wakeup], []
+
+        @selectables.each do |io, monitor|
+          readers << io if monitor.interests == :r || monitor.interests == :rw
+          writers << io if monitor.interests == :w || monitor.interests == :rw
+        end
+
+        ready_readers, ready_writers = Kernel.select readers, writers, [], timeout
+        return unless ready_readers # timeout or wakeup
+
+        results = ready_readers
+        results.concat ready_writers if ready_writers
+
+        results.map! do |io|
+          if io == @wakeup
+            # Clear all wakeup signals we've received by reading them
+            # Wakeups should have level triggered behavior
+            begin
+              @wakeup.read_nonblock(1024)
+
+              # Loop until we've drained all incoming events
+              redo
+            rescue Errno::EWOULDBLOCK
+            end
+
+            return
+          else
+            @selectables[io]
+          end
+        end
+      end
+    end
+
+    # Wake up other threads waiting on this selector
+    def wakeup
+      # Send the selector a signal in the form of writing data to a pipe
+      @waker << "\0"
+      nil
+    end
+
+    # Close this selector and free its resources
+    def close
+      @lock.synchronize do
+        return if @closed
+
+        @wakeup.close rescue nil
+        @waker.close rescue nil
+        @closed = true
+      end
+    end
+
+    # Is this selector closed?
+    def closed?; @closed end
+  end
+end

data/lib/nio/version.rb

@@ -0,0 +1,3 @@
+module NIO
+  VERSION = "0.0.1"
+end

data/nio4r.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/nio/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Tony Arcieri"]
+  gem.email         = ["tony.arcieri@gmail.com"]
+  gem.description   = "New IO for Ruby"
+  gem.summary       = "NIO exposes a set of high performance IO operations on sockets, files, and other Ruby IO objects"
+  gem.homepage      = "https://github.com/tarcieri/nio4r"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "nio4r"
+  gem.require_paths = ["lib"]
+  gem.version       = NIO::VERSION
+
+  gem.add_development_dependency "rake-compiler", "~> 0.7.9"
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "rspec", ">= 2.7.0"
+end

data/spec/nio/monitor_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe NIO::Monitor do
+  let :readable_pipe do
+    pipe, peer = IO.pipe
+    peer << "data"
+    pipe
+  end
+
+  # let :unreadable_pipe do
+  #   pipe, _ = IO.pipe
+  #   pipe
+  # end
+
+  let :selector do
+    NIO::Selector.new
+  end
+
+  # Monitors are created by registering IO objects or channels with a selector
+  subject { selector.register(readable_pipe, :r) }
+
+  it "knows its interests" do
+    subject.interests.should == :r
+  end
+
+  it "stores arbitrary values" do
+    subject.value = 42
+    subject.value.should == 42
+  end
+
+  it "closes" do
+    subject.should_not be_closed
+    subject.close
+    subject.should be_closed
+  end
+end

data/spec/nio/selector_spec.rb

@@ -0,0 +1,197 @@
+require 'spec_helper'
+
+# Timeouts should be at least this precise (in seconds) to pass the tests
+# Typical precision should be better than this, but if it's worse it will fail
+# the tests
+TIMEOUT_PRECISION = 0.1
+
+describe NIO::Selector do
+  it "monitors IO objects" do
+    pipe, _ = IO.pipe
+
+    monitor = subject.register(pipe, :r)
+    monitor.should_not be_closed
+  end
+
+  it "knows which IO objects are registered" do
+    reader, writer = IO.pipe
+    subject.register(reader, :r)
+
+    subject.should be_registered(reader)
+    subject.should_not be_registered(writer)
+  end
+
+  it "deregisters IO objects" do
+    pipe, _ = IO.pipe
+
+    subject.register(pipe, :r)
+    monitor = subject.deregister(pipe)
+    subject.should_not be_registered(pipe)
+    monitor.should be_closed
+  end
+
+  context "select" do
+    it "waits for a timeout when selecting" do
+      reader, writer = IO.pipe
+      monitor = subject.register(reader, :r)
+
+      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)
+
+      started_at = Time.now
+      subject.select(timeout).should be_nil
+      (Time.now - started_at).should be_within(TIMEOUT_PRECISION).of(timeout)
+    end
+
+    it "wakes up if signaled to from another thread" do
+      pipe, _ = IO.pipe
+      subject.register(pipe, :r)
+
+      thread = Thread.new do
+        started_at = Time.now
+        subject.select.should be_nil
+        Time.now - started_at
+      end
+
+      timeout = 0.1
+      sleep timeout
+      subject.wakeup
+
+      thread.value.should be_within(TIMEOUT_PRECISION).of(timeout)
+    end
+  end
+
+  it "closes" 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
+        TCPServer.new("localhost", tcp_port + 1)
+        TCPSocket.open("localhost", tcp_port + 1)
+      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
+end