nio4r 0.2.0 → 2.7.5

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,135 +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
-      @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/nio4r.gemspec

@@ -1,22 +0,0 @@
-# -*- 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 provides a high performance selector API for monitoring 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.extensions    = ["ext/nio4r/extconf.rb"]
-
-  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

@@ -1,46 +0,0 @@
-require 'spec_helper'
-
-describe NIO::Monitor do
-  let :readable do
-    reader, writer = IO.pipe
-    writer << "have some data"
-    reader
-  end
-
-  let :selector do
-    NIO::Selector.new
-  end
-
-  # Monitors are created by registering IO objects or channels with a selector
-  subject { selector.register(readable, :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 "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
-    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
-  end
-
-  it "closes" do
-    subject.should_not be_closed
-    subject.close
-    subject.should be_closed
-  end
-end

data/spec/nio/selector_spec.rb

@@ -1,269 +0,0 @@
-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
-
-  context "select_each" do
-    it "iterates across ready selectables" 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 = []
-      subject.select_each { |monitor| readables << monitor }
-
-      readables.should include(monitor1)
-      readables.should include(monitor2)
-      readables.should_not include(monitor3)
-    end
-
-    it "allows new monitors to be registered in the select_each block" do
-      server = TCPServer.new("localhost", 10001)
-
-      monitor = subject.register(server, :r)
-      connector = TCPSocket.open("localhost", 10001)
-
-      block_fired = false
-      subject.select_each do |monitor|
-        block_fired = true
-        socket = server.accept
-        subject.register(socket, :r).should be_a NIO::Monitor
-      end
-
-      block_fired.should be_true
-    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
-        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/spec/spec_helper.rb

@@ -1,3 +0,0 @@
-require 'rubygems'
-require 'bundler/setup'
-require 'nio'

data/tasks/extension.rake

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

data/tasks/rspec.rake

@@ -1,7 +0,0 @@
-require 'rspec/core/rake_task'
-
-RSpec::Core::RakeTask.new
-
-RSpec::Core::RakeTask.new(:rcov) do |task|
-    task.rcov = true
-end