nio4r 2.3.1 → 2.4.0

data/lib/nio/selector.rb

@@ -44,7 +44,9 @@ module NIO
     # * :w - is the IO writeable?
     # * :rw - is the IO either readable or writeable?
     def register(io, interest)
-      io = IO.try_convert(io)
+      unless io.is_a? OpenSSL::SSL::SSLSocket
+        io = IO.try_convert(io)
+      end
 
       @lock.synchronize do
         raise IOError, "selector is closed" if closed?

data/lib/nio/version.rb

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

data/nio4r.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
   spec.version       = NIO::VERSION
 
-  spec.required_ruby_version = ">= 2.2.2"
+  spec.required_ruby_version = ">= 2.3"
 
   if defined? JRUBY_VERSION
     spec.files << "lib/nio4r_ext.jar"

data/{tasks → rakelib}/extension.rake

@@ -4,6 +4,8 @@ if defined? JRUBY_VERSION
   require "rake/javaextensiontask"
   Rake::JavaExtensionTask.new("nio4r_ext") do |ext|
     ext.ext_dir = "ext/nio4r"
+    ext.source_version = "1.8"
+    ext.target_version = "1.8"
   end
 else
   require "rake/extensiontask"

data/spec/nio/acceptables_spec.rb

@@ -17,16 +17,14 @@ RSpec.describe "NIO acceptables" do
   end
 
   describe TCPServer do
-    let(:port) { next_available_tcp_port }
-
     let :acceptable_subject do
-      server = TCPServer.new("127.0.0.1", port)
-      TCPSocket.open("127.0.0.1", port)
+      server = TCPServer.new("127.0.0.1", 0)
+      TCPSocket.open("127.0.0.1", server.local_address.ip_port)
       server
     end
 
     let :unacceptable_subject do
-      TCPServer.new("127.0.0.1", port + 1)
+      TCPServer.new("127.0.0.1", 0)
     end
 
     it_behaves_like "an NIO acceptable"

data/spec/nio/bytebuffer_spec.rb

@@ -2,7 +2,6 @@
 
 require "spec_helper"
 
-# rubocop:disable Metrics/BlockLength
 RSpec.describe NIO::ByteBuffer do
   let(:capacity)       { 256 }
   let(:example_string) { "Testing 1 2 3..." }
@@ -288,8 +287,8 @@ RSpec.describe NIO::ByteBuffer do
 
   context "I/O" do
     let(:addr)   { "127.0.0.1" }
-    let(:port)   { next_available_tcp_port }
-    let(:server) { TCPServer.new(addr, port) }
+    let(:server) { TCPServer.new(addr, 0) }
+    let(:port)   { server.local_address.ip_port }
     let(:client) { TCPSocket.new(addr, port) }
     let(:peer)   { server_thread.value }
 

data/spec/nio/monitor_spec.rb

@@ -5,9 +5,9 @@ require "socket"
 
 RSpec.describe NIO::Monitor do
   let(:addr) { "127.0.0.1" }
-  let(:port) { next_available_tcp_port }
 
-  let(:reader) { TCPServer.new(addr, port) }
+  let(:reader) { TCPServer.new(addr, 0) }
+  let(:port) { reader.local_address.ip_port }
   let(:writer) { TCPSocket.new(addr, port) }
 
   let(:selector) { NIO::Selector.new }

data/spec/nio/selectables/ssl_socket_spec.rb

@@ -4,10 +4,13 @@ require "spec_helper"
 require "openssl"
 
 RSpec.describe OpenSSL::SSL::SSLSocket do
+  before(:all) do
+    @tls = []
+  end
+
   let(:addr) { "127.0.0.1" }
-  let(:port) { next_available_tcp_port }
 
-  let(:ssl_key) { OpenSSL::PKey::RSA.new(1024) }
+  let(:ssl_key) { OpenSSL::PKey::RSA.new(2048) }
 
   let(:ssl_cert) do
     name = OpenSSL::X509::Name.new([%w[CN 127.0.0.1]])
@@ -28,12 +31,19 @@ RSpec.describe OpenSSL::SSL::SSLSocket do
     OpenSSL::SSL::SSLContext.new.tap do |ctx|
       ctx.cert = ssl_cert
       ctx.key = ssl_key
+      unless @tls.empty?
+        if ctx.respond_to? :set_minmax_proto_version, true
+          ctx.max_version = @tls[0]
+        else
+          ctx.ssl_version = @tls[1]
+        end
+      end
     end
   end
 
   let :readable_subject do
-    server = TCPServer.new(addr, port)
-    client = TCPSocket.open(addr, port)
+    server = TCPServer.new(addr, 0)
+    client = TCPSocket.open(addr, server.local_address.ip_port)
     peer = server.accept
 
     ssl_peer = OpenSSL::SSL::SSLSocket.new(peer, ssl_server_context)
@@ -47,16 +57,17 @@ RSpec.describe OpenSSL::SSL::SSLSocket do
 
     ssl_peer.accept
     ssl_peer << "data"
+    ssl_peer.flush
 
     thread.join
-    pending "Failed to produce a readable SSL socket" unless select([ssl_client], [], [], 0)
 
+    pending "Failed to produce a readable socket" unless select([ssl_client], [], [], 10)
     ssl_client
   end
 
   let :unreadable_subject do
-    server = TCPServer.new(addr, port)
-    client = TCPSocket.new(addr, port)
+    server = TCPServer.new(addr, 0)
+    client = TCPSocket.new(addr, server.local_address.ip_port)
     peer = server.accept
 
     ssl_peer = OpenSSL::SSL::SSLSocket.new(peer, ssl_server_context)
@@ -70,13 +81,17 @@ RSpec.describe OpenSSL::SSL::SSLSocket do
     ssl_peer.accept
     thread.join
 
+    if ssl_client.ssl_version == "TLSv1.3"
+      expect(ssl_client.read_nonblock(1, exception: false)).to eq(:wait_readable)
+    end
+
     pending "Failed to produce an unreadable socket" if select([ssl_client], [], [], 0)
     ssl_client
   end
 
   let :writable_subject do
-    server = TCPServer.new(addr, port)
-    client = TCPSocket.new(addr, port)
+    server = TCPServer.new(addr, 0)
+    client = TCPSocket.new(addr, server.local_address.ip_port)
     peer = server.accept
 
     ssl_peer = OpenSSL::SSL::SSLSocket.new(peer, ssl_server_context)
@@ -95,8 +110,8 @@ RSpec.describe OpenSSL::SSL::SSLSocket do
   end
 
   let :unwritable_subject do
-    server = TCPServer.new(addr, port)
-    client = TCPSocket.new(addr, port)
+    server = TCPServer.new(addr, 0)
+    client = TCPSocket.new(addr, server.local_address.ip_port)
     peer = server.accept
 
     ssl_peer = OpenSSL::SSL::SSLSocket.new(peer, ssl_server_context)
@@ -128,22 +143,22 @@ RSpec.describe OpenSSL::SSL::SSLSocket do
 
     # Once more for good measure!
     begin
-      #        ssl_client.write_nonblock "X" * 1024
+      # ssl_client.write_nonblock "X" * 1024
       loop { ssl_client.write_nonblock "X" * 1024 }
     rescue OpenSSL::SSL::SSLError
     end
 
     # Sanity check to make sure we actually produced an unwritable socket
-    #      if select([], [ssl_client], [], 0)
-    #        pending "Failed to produce an unwritable socket"
-    #      end
+    if select([], [ssl_client], [], 0)
+      pending "Failed to produce an unwritable socket"
+    end
 
     ssl_client
   end
 
   let :pair do
-    server = TCPServer.new(addr, port)
-    client = TCPSocket.new(addr, port)
+    server = TCPServer.new(addr, 0)
+    client = TCPSocket.new(addr, server.local_address.ip_port)
     peer = server.accept
 
     ssl_peer = OpenSSL::SSL::SSLSocket.new(peer, ssl_server_context)
@@ -159,6 +174,19 @@ RSpec.describe OpenSSL::SSL::SSLSocket do
     [thread.value, ssl_peer]
   end
 
-  it_behaves_like "an NIO selectable"
-  it_behaves_like "an NIO selectable stream"
+  describe "using TLS 1.2" do
+    before(:all) do
+      @tls = %i[TLS1_2 TLSv1_2]
+    end
+    it_behaves_like "an NIO selectable"
+    it_behaves_like "an NIO selectable stream"
+  end
+
+  describe "using TLS 1.3", if: OpenSSL::SSL.const_defined?(:TLS1_3_VERSION) do
+    before(:all) do
+      @tls = %i[TLS1_3 TLSv1_3]
+    end
+    it_behaves_like "an NIO selectable"
+    it_behaves_like "an NIO selectable stream", true
+  end
 end

data/spec/nio/selectables/tcp_socket_spec.rb

@@ -4,19 +4,22 @@ require "spec_helper"
 
 RSpec.describe TCPSocket do
   let(:addr) { "127.0.0.1" }
-  let(:port) { next_available_tcp_port }
 
   let :readable_subject do
-    server = TCPServer.new(addr, port)
-    sock = TCPSocket.new(addr, port)
+    server = TCPServer.new(addr, 0)
+    sock = TCPSocket.new(addr, server.local_address.ip_port)
     peer = server.accept
-    peer << "data"
+
+    peer << "Xdata"
+    peer.flush
+    sock.read(1)
+
     sock
   end
 
   let :unreadable_subject do
-    TCPServer.new(addr, port)
-    sock = TCPSocket.new(addr, port)
+    server = TCPServer.new(addr, 0)
+    sock = TCPSocket.new(addr, server.local_address.ip_port)
 
     # Sanity check to make sure we actually produced an unreadable socket
     pending "Failed to produce an unreadable socket" if select([sock], [], [], 0)
@@ -25,13 +28,13 @@ RSpec.describe TCPSocket do
   end
 
   let :writable_subject do
-    TCPServer.new(addr, port)
-    TCPSocket.new(addr, port)
+    server = TCPServer.new(addr, 0)
+    TCPSocket.new(addr, server.local_address.ip_port)
   end
 
   let :unwritable_subject do
-    server = TCPServer.new(addr, port)
-    sock = TCPSocket.new(addr, port)
+    server = TCPServer.new(addr, 0)
+    sock = TCPSocket.new(addr, server.local_address.ip_port)
 
     # TODO: close this socket
     _peer = server.accept
@@ -61,8 +64,8 @@ RSpec.describe TCPSocket do
   end
 
   let :pair do
-    server = TCPServer.new(addr, port)
-    client = TCPSocket.new(addr, port)
+    server = TCPServer.new(addr, 0)
+    client = TCPSocket.new(addr, server.local_address.ip_port)
     [client, server.accept]
   end
 
@@ -71,19 +74,22 @@ RSpec.describe TCPSocket do
   it_behaves_like "an NIO bidirectional stream"
 
   context :connect do
-    it "selects writable when connected", retry: 5 do # retry: Flaky on OS X
+    include_context NIO::Selector
+
+    it "selects writable when connected" do
       begin
-        server = TCPServer.new(addr, port)
-        selector = NIO::Selector.new
+        server = TCPServer.new(addr, 0)
 
         client = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
         monitor = selector.register(client, :w)
 
         expect do
-          client.connect_nonblock Socket.sockaddr_in(port, addr)
+          client.connect_nonblock server.local_address
         end.to raise_exception Errno::EINPROGRESS
 
-        expect(selector.select(0.001)).to include monitor
+        ready = selector.select(1)
+
+        expect(ready).to include monitor
         result = client.getsockopt(::Socket::SOL_SOCKET, ::Socket::SO_ERROR)
         expect(result.unpack("i").first).to be_zero
       ensure

data/spec/nio/selectables/udp_socket_spec.rb

@@ -6,32 +6,37 @@ RSpec.describe UDPSocket, if: !defined?(JRUBY_VERSION) do
   let(:udp_port) { 23_456 }
 
   let :readable_subject do
-    sock = UDPSocket.new
-    sock.bind("127.0.0.1", udp_port)
+    server = UDPSocket.new
+    server.bind("127.0.0.1", 0)
 
     peer = UDPSocket.new
-    peer.send("hi there", 0, "127.0.0.1", udp_port)
+    peer.send("hi there", 0, "127.0.0.1", server.local_address.ip_port)
 
-    sock
+    server
   end
 
   let :unreadable_subject do
     sock = UDPSocket.new
-    sock.bind("127.0.0.1", udp_port + 1)
+    sock.bind("127.0.0.1", 0)
     sock
   end
 
   let :writable_subject do
+    server = UDPSocket.new
+    server.bind("127.0.0.1", 0)
+
     peer = UDPSocket.new
-    peer.connect "127.0.0.1", udp_port
+    peer.connect("127.0.0.1", server.local_address.ip_port)
+
     cntr = 0
     begin
       peer.send("X" * 1024, 0)
       cntr += 1
       t = select [], [peer], [], 0
     rescue Errno::ECONNREFUSED => ex
-      skip "Couln't make writable UDPSocket subject: #{ex.class}: #{ex}"
+      skip "Couldn't make writable UDPSocket subject: #{ex.class}: #{ex}"
     end while t && t[1].include?(peer) && cntr < 5
+
     peer
   end
 

data/spec/nio/selector_spec.rb

@@ -3,12 +3,6 @@
 require "spec_helper"
 require "timeout"
 
-# 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
-
-# rubocop:disable Metrics/BlockLength
 RSpec.describe NIO::Selector do
   let(:pair)   { IO.pipe }
   let(:reader) { pair.first }
@@ -96,31 +90,37 @@ RSpec.describe NIO::Selector do
   end
 
   context "timeouts" do
+    let(:select_precision) {0.2}
+    let(:payload) {"hi there"}
+
     it "waits for a timeout when selecting" do
       monitor = subject.register(reader, :r)
 
-      payload = "hi there"
       writer << payload
 
       timeout = 0.5
       started_at = Time.now
       expect(subject.select(timeout)).to include monitor
-      expect(Time.now - started_at).to be_within(TIMEOUT_PRECISION).of(0)
+      expect(Time.now - started_at).to be_within(select_precision).of(0)
       reader.read_nonblock(payload.size)
 
       started_at = Time.now
       expect(subject.select(timeout)).to be_nil
-      expect(Time.now - started_at).to be_within(TIMEOUT_PRECISION).of(timeout)
+      expect(Time.now - started_at).to be_within(select_precision).of(timeout)
     end
 
     it "raises ArgumentError if given a negative timeout" do
       subject.register(reader, :r)
 
-      expect { subject.select(-1) }.to raise_exception(ArgumentError)
+      expect do
+        subject.select(-1)
+      end.to raise_exception(ArgumentError)
     end
   end
 
   context "wakeup" do
+    let(:select_precision) {0.2}
+
     it "wakes up if signaled to from another thread" do
       subject.register(reader, :r)
 
@@ -134,7 +134,7 @@ RSpec.describe NIO::Selector do
       sleep timeout
       subject.wakeup
 
-      expect(thread.value).to be_within(TIMEOUT_PRECISION).of(timeout)
+      expect(thread.value).to be_within(select_precision).of(timeout)
     end
 
     it "raises IOError if asked to wake up a closed selector" do

data/spec/spec_helper.rb

@@ -5,26 +5,14 @@ Coveralls.wear!
 
 require "nio"
 require "support/selectable_examples"
-require "rspec/retry"
 
 RSpec.configure do |config|
   config.disable_monkey_patching!
-  config.verbose_retry = true
-  config.display_try_failure_messages = true
-end
-
-$current_tcp_port = 10_000
-
-def next_available_tcp_port
-  loop do
-    $current_tcp_port += 1
 
-    begin
-      sock = Timeout.timeout(0.5) { TCPSocket.new("127.0.0.1", $current_tcp_port) }
-    rescue Errno::ECONNREFUSED, Timeout::Error
-      break $current_tcp_port
-    end
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
 
-    sock.close
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
   end
 end