nio4r 2.0.0.pre → 2.0.0

data/lib/nio/selector.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "set"
 
 module NIO
@@ -13,17 +15,33 @@ module NIO
       @closed = false
     end
 
+    # Return a symbol representing the backend I/O multiplexing mechanism used.
+    # Supported backends are:
+    # * :ruby    - pure Ruby (i.e IO.select)
+    # * :java    - Java NIO on JRuby
+    # * :epoll   - libev w\ Linux epoll
+    # * :poll    - libev w\ POSIX poll
+    # * :kqueue  - libev w\ BSD kqueue
+    # * :select  - libev w\ SysV select
+    # * :port    - libev w\ I/O completion ports
+    # * :unknown - libev w\ unknown backend
+    def backend
+      :ruby
+    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)
+      io = IO.try_convert(io)
+
       @lock.synchronize do
-        fail IOError, "selector is closed" if closed?
+        raise IOError, "selector is closed" if closed?
 
         monitor = @selectables[io]
-        fail ArgumentError, "already registered as #{monitor.interests.inspect}" if monitor
+        raise ArgumentError, "already registered as #{monitor.interests.inspect}" if monitor
 
         monitor = Monitor.new(io, interest, self)
         @selectables[monitor.io] = monitor
@@ -35,7 +53,7 @@ module NIO
     # Deregister the given IO object from the selector
     def deregister(io)
       @lock.synchronize do
-        monitor = @selectables.delete io
+        monitor = @selectables.delete IO.try_convert(io)
         monitor.close(false) if monitor && !monitor.closed?
         monitor
       end
@@ -60,15 +78,14 @@ module NIO
           monitor.readiness = nil
         end
 
-        ready_readers, ready_writers = Kernel.select readers, writers, [], timeout
-        return unless ready_readers # timeout or wakeup
+        ready_readers, ready_writers = Kernel.select(readers, writers, [], timeout)
+        return unless ready_readers # timeout
 
         ready_readers.each do |io|
           if io == @wakeup
             # Clear all wakeup signals we've received by reading them
             # Wakeups should have level triggered behavior
             @wakeup.read(@wakeup.stat.size)
-            return
           else
             monitor = @selectables[io]
             monitor.readiness = :r
@@ -78,18 +95,16 @@ module NIO
 
         ready_writers.each do |io|
           monitor = @selectables[io]
-          monitor.readiness = (monitor.readiness == :r) ? :rw : :w
+          monitor.readiness = monitor.readiness == :r ? :rw : :w
           selected_monitors << monitor
         end
       end
 
       if block_given?
-        selected_monitors.each do |m|
-          yield m
-        end
+        selected_monitors.each { |m| yield m }
         selected_monitors.size
       else
-        selected_monitors
+        selected_monitors.to_a
       end
     end
 
@@ -119,8 +134,16 @@ module NIO
       @lock.synchronize do
         return if @closed
 
-        @wakeup.close rescue nil
-        @waker.close rescue nil
+        begin
+          @wakeup.close
+        rescue IOError
+        end
+
+        begin
+          @waker.close
+        rescue IOError
+        end
+
         @closed = true
       end
     end

data/lib/nio/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module NIO
-  VERSION = "2.0.0.pre".freeze
+  VERSION = "2.0.0"
 end

data/nio4r.gemspec

@@ -1,28 +1,34 @@
-# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
+
 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/celluloid/nio4r"
-  gem.license       = "MIT"
+Gem::Specification.new do |spec|
+  spec.authors       = ["Tony Arcieri"]
+  spec.email         = ["bascule@gmail.com"]
+  spec.homepage      = "https://github.com/socketry/nio4r"
+  spec.license       = "MIT"
+  spec.summary       = "New IO for Ruby"
+  spec.description   = <<-DESCRIPTION.strip.gsub(/\s+/, " ")
+     Cross-platform asynchronous I/O primitives for scalable network clients
+     and servers. Inspired by the Java NIO API, but simplified for ease-of-use.
+  DESCRIPTION
+
+  spec.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  spec.files         = `git ls-files`.split("\n")
+  spec.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  spec.name          = "nio4r"
+  spec.require_paths = ["lib"]
+  spec.version       = NIO::VERSION
 
-  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
+  spec.required_ruby_version = ">= 2.2.2"
 
   if defined? JRUBY_VERSION
-    gem.files << "lib/nio4r_ext.jar"
-    gem.platform = "java"
+    spec.files << "lib/nio4r_ext.jar"
+    spec.platform = "java"
   else
-    gem.extensions = ["ext/nio4r/extconf.rb"]
+    spec.extensions = ["ext/nio4r/extconf.rb"]
   end
 
-  gem.add_development_dependency "rake"
-  gem.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "bundler"
 end

data/spec/nio/acceptables_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 RSpec.describe "NIO acceptables" do
@@ -15,16 +17,16 @@ RSpec.describe "NIO acceptables" do
   end
 
   describe TCPServer do
-    let(:tcp_port) { 23_456 }
+    let(:port) { next_available_tcp_port }
 
     let :acceptable_subject do
-      server = TCPServer.new("localhost", tcp_port)
-      TCPSocket.open("localhost", tcp_port)
+      server = TCPServer.new("localhost", port)
+      TCPSocket.open("localhost", port)
       server
     end
 
     let :unacceptable_subject do
-      TCPServer.new("localhost", tcp_port + 1)
+      TCPServer.new("localhost", port + 1)
     end
 
     it_behaves_like "an NIO acceptable"

data/spec/nio/bytebuffer_spec.rb

@@ -1,76 +1,348 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 RSpec.describe NIO::ByteBuffer do
-  describe "#Behaviour of ByteBuffer" do
-    subject { bytebuffer }
+  let(:capacity)       { 256 }
+  let(:example_string) { "Testing 1 2 3..." }
+  subject(:bytebuffer) { described_class.new(capacity) }
 
-    context "allocates a given size buffer" do
-      let(:bytebuffer) { NIO::ByteBuffer.new(256, nil, nil) }
+  describe "#initialize" do
+    it "raises TypeError if given a bogus argument" do
+      expect { described_class.new(:symbols_are_bogus) }.to raise_error(TypeError)
+    end
+  end
 
-      before :each do
-        bytebuffer.clear
-      end
+  describe "#clear" do
+    it "clears the buffer" do
+      bytebuffer << example_string
+      bytebuffer.clear
 
-      it "Checks the allocation" do
-        expect(bytebuffer.capacity).to eql(256)
-      end
+      expect(bytebuffer.remaining).to eq capacity
+    end
+  end
 
-      it "checks remaining" do
-        expect(bytebuffer.remaining).to eql(256)
-      end
+  describe "#position" do
+    it "defaults to zero" do
+      expect(bytebuffer.position).to be_zero
+    end
+  end
 
-      it "puts a given string to buffer" do
-        bytebuffer << "Song of Ice & Fire"
-        expect(bytebuffer.remaining).to eql(238)
-      end
+  describe "#position=" do
+    let(:example_position) { 42 }
+
+    it "sets the buffer's position to a valid value" do
+      expect(bytebuffer.position).to be_zero
+      bytebuffer.position = example_position
+      expect(bytebuffer.position).to eq example_position
+    end
+
+    it "raises ArgumentError if the specified position is less than zero" do
+      expect { bytebuffer.position = -1 }.to raise_error(ArgumentError)
+    end
+
+    it "raises ArgumentError if the specified position exceeds the limit" do
+      expect { bytebuffer.position = capacity + 1 }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#limit" do
+    it "defaults to the buffer's capacity" do
+      expect(bytebuffer.limit).to eq capacity
+    end
+  end
+
+  describe "#limit=" do
+    it "sets the buffer's limit to a valid value" do
+      bytebuffer.flip
+      expect(bytebuffer.limit).to be_zero
+
+      new_limit = capacity / 2
+      bytebuffer.limit = new_limit
+      expect(bytebuffer.limit).to eq new_limit
+    end
+
+    it "preserves position and mark if they're less than the new limit" do
+      bytebuffer << "four"
+      bytebuffer.mark
+      bytebuffer << "more"
+
+      bytebuffer.limit = capacity / 2
+      expect(bytebuffer.position).to eq 8
+      bytebuffer.reset
+      expect(bytebuffer.position).to eq 4
+    end
+
+    it "sets position to the new limit if the previous position is beyond the limit" do
+      bytebuffer << "four"
+      bytebuffer.limit = 2
+      expect(bytebuffer.position).to eq 2
+    end
+
+    it "clears the mark if the new limit is before the current mark" do
+      bytebuffer << "four"
+      bytebuffer.mark
+      bytebuffer.limit = 2
+      expect { bytebuffer.reset }.to raise_error(NIO::ByteBuffer::MarkUnsetError)
+    end
 
-      it "reads the content added" do
-        bytebuffer << "Test"
-        bytebuffer << "Text"
-        bytebuffer << "Dumb"
+    it "raises ArgumentError if specified limit is less than zero" do
+      expect { bytebuffer.limit = -1 }.to raise_error(ArgumentError)
+    end
+
+    it "raises ArgumentError if specified limit exceeds capacity" do
+      expect { bytebuffer.limit = capacity }.not_to raise_error
+      expect { bytebuffer.limit = capacity + 1 }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#capacity" do
+    it "has the requested capacity" do
+      expect(bytebuffer.capacity).to eq capacity
+    end
+  end
+
+  describe "#remaining" do
+    it "calculates the number of bytes remaining" do
+      expect(bytebuffer.remaining).to eq capacity
+      bytebuffer << example_string
+      expect(bytebuffer.remaining).to eq(capacity - example_string.length)
+    end
+  end
+
+  describe "#full?" do
+    it "returns false when there is space remaining in the buffer" do
+      expect(bytebuffer).not_to be_full
+    end
+
+    it "returns true when the buffer is full" do
+      bytebuffer << "X" * capacity
+      expect(bytebuffer).to be_full
+    end
+  end
+
+  describe "#get" do
+    it "reads all remaining data if no length is given" do
+      bytebuffer << example_string
+      bytebuffer.flip
+
+      expect(bytebuffer.get).to eq example_string
+    end
+
+    it "reads zeroes from a newly initialized buffer" do
+      expect(bytebuffer.get(capacity)).to eq("\0" * capacity)
+    end
+
+    it "advances position as data is read" do
+      bytebuffer << "First"
+      bytebuffer << "Second"
+      bytebuffer << "Third"
+      bytebuffer.flip
+
+      expect(bytebuffer.position).to be_zero
+      expect(bytebuffer.get(10)).to eq "FirstSecon"
+      expect(bytebuffer.position).to eq 10
+    end
+
+    it "raises NIO::ByteBuffer::UnderflowError if there is not enough data in the buffer" do
+      bytebuffer << example_string
+      bytebuffer.flip
+
+      expect { bytebuffer.get(example_string.length + 1) }.to raise_error(NIO::ByteBuffer::UnderflowError)
+      expect(bytebuffer.get(example_string.length)).to eq example_string
+    end
+  end
+
+  describe "#[]" do
+    it "obtains bytes at a given index without altering position" do
+      bytebuffer << example_string
+      expect(bytebuffer[7]).to eq example_string.bytes[7]
+      expect(bytebuffer.position).to eq example_string.length
+    end
+
+    it "raises ArgumentError if the index is less than zero" do
+      expect { bytebuffer[-1] }.to raise_error(ArgumentError)
+    end
+
+    it "raises ArgumentError if the index exceeds the limit" do
+      bytebuffer << example_string
+      bytebuffer.flip
+      expect(bytebuffer[bytebuffer.limit - 1]).to eq example_string.bytes.last
+      expect { bytebuffer[bytebuffer.limit] }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#<<" do
+    it "adds strings to the buffer" do
+      bytebuffer << example_string
+      expect(bytebuffer.position).to eq example_string.length
+      expect(bytebuffer.limit).to eq capacity
+    end
+
+    it "raises NIO::ByteBuffer::OverflowError if the buffer is full" do
+      bytebuffer << "X" * (capacity - 1)
+      expect { bytebuffer << "X" }.not_to raise_error
+      expect { bytebuffer << "X" }.to raise_error(NIO::ByteBuffer::OverflowError)
+    end
+  end
+
+  describe "#flip" do
+    it "flips the bytebuffer" do
+      bytebuffer << example_string
+      expect(bytebuffer.position).to eql example_string.length
+
+      expect(bytebuffer.flip).to eq bytebuffer
+
+      expect(bytebuffer.position).to be_zero
+      expect(bytebuffer.limit).to eq example_string.length
+      expect(bytebuffer.get).to eq example_string
+    end
+
+    it "sets remaining to the previous position" do
+      bytebuffer << example_string
+      previous_position = bytebuffer.position
+      expect(bytebuffer.remaining).to eq(capacity - previous_position)
+      expect(bytebuffer.flip.remaining).to eq previous_position
+    end
+
+    it "sets limit to the previous position" do
+      bytebuffer << example_string
+      expect(bytebuffer.limit).to eql(capacity)
+
+      previous_position = bytebuffer.position
+      expect(bytebuffer.flip.limit).to eql previous_position
+    end
+  end
+
+  describe "#rewind" do
+    it "rewinds the buffer leaving the limit intact" do
+      bytebuffer << example_string
+      expect(bytebuffer.rewind).to eq bytebuffer
+
+      expect(bytebuffer.position).to be_zero
+      expect(bytebuffer.limit).to eq capacity
+    end
+  end
+
+  describe "#mark" do
+    it "returns self" do
+      expect(bytebuffer.mark).to eql bytebuffer
+    end
+  end
+
+  describe "#reset" do
+    it "returns to a previously marked position" do
+      bytebuffer << "First"
+      expected_position = bytebuffer.position
+
+      expect(bytebuffer.mark).to eq bytebuffer
+      bytebuffer << "Second"
+      expect(bytebuffer.position).not_to eq expected_position
+      expect(bytebuffer.reset.position).to eq expected_position
+    end
+
+    it "raises NIO::ByteBuffer::MarkUnsetError unless mark has been set" do
+      expect { bytebuffer.reset }.to raise_error(NIO::ByteBuffer::MarkUnsetError)
+    end
+  end
+
+  describe "#compact" do
+    let(:first_string)  { "CompactMe" }
+    let(:second_string) { "Leftover" }
+
+    it "copies data from the current position to the beginning of the buffer" do
+      bytebuffer << first_string << second_string
+      bytebuffer.position = first_string.length
+      bytebuffer.limit = first_string.length + second_string.length
+      bytebuffer.compact
+
+      expect(bytebuffer.position).to eq second_string.length
+      expect(bytebuffer.limit).to eq capacity
+      expect(bytebuffer.flip.get).to eq second_string
+    end
+  end
+
+  describe "#each" do
+    it "iterates over data in the buffer" do
+      bytebuffer << example_string
+      bytebuffer.flip
+
+      bytes = []
+      bytebuffer.each { |byte| bytes << byte }
+      expect(bytes).to eq example_string.bytes
+    end
+  end
+
+  describe "#inspect" do
+    it "inspects the buffer offsets" do
+      regex = /\A#<NIO::ByteBuffer:.*? @position=0 @limit=#{capacity} @capacity=#{capacity}>\z/
+      expect(bytebuffer.inspect).to match(regex)
+    end
+  end
+
+  context "I/O" do
+    let(:addr)   { "localhost" }
+    let(:port)   { next_available_tcp_port }
+    let(:server) { TCPServer.new(addr, port) }
+    let(:client) { TCPSocket.new(addr, port) }
+    let(:peer)   { server_thread.value }
+
+    let(:server_thread) do
+      server
+
+      thread = Thread.new { server.accept }
+      Thread.pass while thread.status && thread.status != "sleep"
+
+      thread
+    end
+
+    before do
+      server_thread
+      client
+    end
+
+    after do
+      server_thread.kill if server_thread.alive?
+
+      server.close rescue nil
+      client.close rescue nil
+      peer.close rescue nil
+    end
+
+    describe "#read_from" do
+      it "reads data into the buffer" do
+        client.write(example_string)
+        expect(bytebuffer.read_from(peer)).to eq example_string.length
         bytebuffer.flip
-        expect(bytebuffer.read_next(5)).to eql "TestT"
-      end
 
-      it "rewinds the buffer" do
+        expect(bytebuffer.get).to eq example_string
       end
 
-      it "compacts the buffer" do
-        bytebuffer << "Test"
-        bytebuffer << " Text"
-        bytebuffer << "Dumb"
-        bytebuffer.flip
-        bytebuffer.read_next 5
-        bytebuffer.compact
-        bytebuffer << " RRMARTIN"
-        bytebuffer.flip
-        # expect(bytebuffer.limit?).to eql(10)
-        expect(bytebuffer.get).to eql("TextDumb RRMARTIN")
+      it "raises NIO::ByteBuffer::OverflowError if the buffer is already full" do
+        client.write(example_string)
+        bytebuffer << "X" * capacity
+        expect { bytebuffer.read_from(peer) }.to raise_error(NIO::ByteBuffer::OverflowError)
       end
 
-      it "flips the bytebuffer" do
-        bytebuffer << "Test"
-        bytebuffer.flip
-        expect(bytebuffer.get).to eql("Test")
+      it "returns 0 if no data is available" do
+        expect(bytebuffer.read_from(peer)).to eq 0
       end
+    end
 
-      it "reads the next items" do
-        bytebuffer << "John Snow"
+    describe "#write_to" do
+      it "writes data from the buffer" do
+        bytebuffer << example_string
         bytebuffer.flip
-        bytebuffer.read_next 5
-        expect(bytebuffer.read_next(4)).to eql("Snow")
-      end
 
-      it "clears the buffer" do
-        bytebuffer << "Game of Thrones"
-        bytebuffer.clear
-        expect(bytebuffer.remaining).to eql(256)
+        expect(bytebuffer.write_to(client)).to eq example_string.length
+        client.close
+
+        expect(peer.read(example_string.length)).to eq example_string
       end
 
-      it "gets the content of the bytebuffer" do
-        bytebuffer << "Test"
+      it "raises NIO::ByteBuffer::UnderflowError if the buffer is out of data" do
         bytebuffer.flip
-        expect(bytebuffer.get).to eql("Test")
+        expect { bytebuffer.write_to(peer) }.to raise_error(NIO::ByteBuffer::UnderflowError)
       end
     end
   end