nio4r 1.2.1 → 2.5.3

data/spec/nio/selectables/tcp_socket_spec.rb

@@ -1,45 +1,52 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 RSpec.describe TCPSocket do
-  port_offset = 0
-  let(:tcp_port) { 12_345 + (port_offset += 1) }
+  let(:addr) { "127.0.0.1" }
 
   let :readable_subject do
-    server = TCPServer.new("localhost", tcp_port)
-    sock = TCPSocket.open("localhost", tcp_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("localhost", tcp_port)
-    sock = TCPSocket.new("localhost", tcp_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
-    if select([sock], [], [], 0)
-      pending "Failed to produce an unreadable socket"
-    end
+    pending "Failed to produce an unreadable socket" if select([sock], [], [], 0)
 
     sock
   end
 
   let :writable_subject do
-    TCPServer.new("localhost", tcp_port)
-    TCPSocket.new("localhost", tcp_port)
+    server = TCPServer.new(addr, 0)
+    TCPSocket.new(addr, server.local_address.ip_port)
   end
 
   let :unwritable_subject do
-    server = TCPServer.new("localhost", tcp_port)
-    sock = TCPSocket.open("localhost", tcp_port)
-    peer = server.accept
+    server = TCPServer.new(addr, 0)
+    sock = TCPSocket.new(addr, server.local_address.ip_port)
 
-    begin
+    # TODO: close this socket
+    _peer = server.accept
+
+    loop do
       sock.write_nonblock "X" * 1024
-      _, writers = select [], [sock], [], 0
-    end while writers && writers.include?(sock)
+      _, writers = Kernel.select([], [sock], [], 0)
+
+      break unless writers && writers.include?(sock)
+    end
 
-    # I think the kernel might manage to drain its buffer a bit even after
+    # HAX: 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
@@ -51,16 +58,14 @@ RSpec.describe TCPSocket do
     end
 
     # Sanity check to make sure we actually produced an unwritable socket
-    if select([], [sock], [], 0)
-      pending "Failed to produce an unwritable socket"
-    end
+    pending "Failed to produce an unwritable socket" if select([], [sock], [], 0)
 
     sock
   end
 
   let :pair do
-    server = TCPServer.new("localhost", tcp_port)
-    client = TCPSocket.open("localhost", tcp_port)
+    server = TCPServer.new(addr, 0)
+    client = TCPSocket.new(addr, server.local_address.ip_port)
     [client, server.accept]
   end
 
@@ -69,20 +74,28 @@ RSpec.describe TCPSocket do
   it_behaves_like "an NIO bidirectional stream"
 
   context :connect do
+    include_context NIO::Selector
+
     it "selects writable when connected" do
-      selector = NIO::Selector.new
-      server = TCPServer.new("127.0.0.1", tcp_port)
+      begin
+        server = TCPServer.new(addr, 0)
+
+        client = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+        monitor = selector.register(client, :w)
 
-      client = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
-      monitor = selector.register(client, :w)
+        expect do
+          client.connect_nonblock server.local_address
+        end.to raise_exception Errno::EINPROGRESS
 
-      expect do
-        client.connect_nonblock Socket.sockaddr_in(tcp_port, "127.0.0.1")
-      end.to raise_exception Errno::EINPROGRESS
+        ready = selector.select(1)
 
-      expect(selector.select(0.001)).to include monitor
-      result = client.getsockopt(::Socket::SOL_SOCKET, ::Socket::SO_ERROR)
-      expect(result.unpack("i").first).to be_zero
+        expect(ready).to include monitor
+        result = client.getsockopt(::Socket::SOL_SOCKET, ::Socket::SO_ERROR)
+        expect(result.unpack("i").first).to be_zero
+      ensure
+        server.close rescue nil
+        selector.close rescue nil
+      end
     end
   end
 end

data/spec/nio/selectables/udp_socket_spec.rb

@@ -1,26 +1,43 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
-RSpec.describe UDPSocket do
+RSpec.describe UDPSocket, if: !defined?(JRUBY_VERSION) do
   let(:udp_port) { 23_456 }
 
   let :readable_subject do
-    sock = UDPSocket.new
-    sock.bind("localhost", udp_port)
+    server = UDPSocket.new
+    server.bind("127.0.0.1", 0)
 
     peer = UDPSocket.new
-    peer.send("hi there", 0, "localhost", 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("localhost", udp_port + 1)
+    sock.bind("127.0.0.1", 0)
     sock
   end
 
   let :writable_subject do
-    pending "come up with a writable UDPSocket example"
+    server = UDPSocket.new
+    server.bind("127.0.0.1", 0)
+
+    peer = UDPSocket.new
+    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 => e
+      skip "Couldn't make writable UDPSocket subject: #{e.class}: #{e}"
+    end while t && t[1].include?(peer) && cntr < 5
+
+    peer
   end
 
   let :unwritable_subject do

data/spec/nio/selector_spec.rb

@@ -1,16 +1,46 @@
+# frozen_string_literal: true
+
 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
-
 RSpec.describe NIO::Selector do
   let(:pair)   { IO.pipe }
   let(:reader) { pair.first }
   let(:writer) { pair.last }
 
+  context ".backends" do
+    it "knows all supported backends" do
+      expect(described_class.backends).to be_a Array
+      expect(described_class.backends.first).to be_a Symbol
+    end
+  end
+
+  context "#initialize" do
+    it "allows explicitly specifying a backend" do |example|
+      backend = described_class.backends.first
+      selector = described_class.new(backend)
+      expect(selector.backend).to eq backend
+
+      example.reporter.message "Supported backends: #{described_class.backends}"
+    end
+
+    it "raises ArgumentError if given an invalid backend" do
+      expect { described_class.new(:derp) }.to raise_error ArgumentError
+    end
+
+    it "raises TypeError if given a non-Symbol parameter" do
+      expect { described_class.new(42).to raise_error TypeError }
+    end
+  end
+
+  context "backend" do
+    it "knows its backend" do |example|
+      expect(subject.backend).to be_a Symbol
+
+      example.reporter.message "Current backend: #{subject.backend}"
+    end
+  end
+
   context "register" do
     it "registers IO objects" do
       monitor = subject.register(reader, :r)
@@ -41,11 +71,18 @@ RSpec.describe NIO::Selector do
     expect(monitor).to be_closed
   end
 
-  it "reports if it is empty" do
-    expect(subject).to be_empty
+  it "allows deregistering closed IO objects" do
+    subject.register(reader, :r)
+    reader.close
 
-    monitor = subject.register(reader, :r)
+    expect do
+      subject.deregister(reader)
+    end.not_to raise_error
+  end
 
+  it "reports if it is empty" do
+    expect(subject).to be_empty
+    subject.register(reader, :r)
     expect(subject).not_to be_empty
   end
 
@@ -66,37 +103,49 @@ RSpec.describe NIO::Selector do
   end
 
   context "timeouts" do
-    it "waits for a timeout when selecting" do
+    let(:select_precision) {0.2}
+    let(:timeout) {2.0}
+    let(:payload) {"hi there"}
+
+    it "waits for timeout when selecting from empty selector" do
+      started_at = Time.now
+      expect(subject.select(timeout)).to be_nil
+      expect(Time.now - started_at).to be_within(select_precision).of(timeout)
+    end
+
+    it "waits for a timeout when selecting with reader" 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)
 
       thread = Thread.new do
         started_at = Time.now
-        expect(subject.select).to be_nil
+        expect(subject.select).to eq []
         Time.now - started_at
       end
 
@@ -104,7 +153,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

@@ -1,9 +1,18 @@
+# frozen_string_literal: true
+
 require "coveralls"
 Coveralls.wear!
 
-require "rubygems"
-require "bundler/setup"
 require "nio"
 require "support/selectable_examples"
 
-RSpec.configure(&:disable_monkey_patching!)
+RSpec.configure do |config|
+  config.disable_monkey_patching!
+
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/spec/support/selectable_examples.rb

@@ -1,42 +1,55 @@
+# frozen_string_literal: true
+
+RSpec.shared_context NIO::Selector do
+  let(:selector) {@selector = NIO::Selector.new}
+
+  after(:each) do
+    if defined?(@selector)
+      @selector.close
+    end
+  end
+end
+
 RSpec.shared_context "an NIO selectable" do
-  let(:selector) { NIO::Selector.new }
+  include_context NIO::Selector
 
   it "selects readable objects" do
     monitor = selector.register(readable_subject, :r)
-    ready = selector.select(0)
+    ready = selector.select(1)
     expect(ready).to be_an Enumerable
     expect(ready).to include monitor
   end
 
   it "does not select unreadable objects" do
-    monitor = selector.register(unreadable_subject, :r)
+    selector.register(unreadable_subject, :r)
     expect(selector.select(0)).to be_nil
   end
 
   it "selects writable objects" do
     monitor = selector.register(writable_subject, :w)
-    ready = selector.select(0)
+    ready = selector.select(1)
     expect(ready).to be_an Enumerable
     expect(ready).to include monitor
   end
 
   it "does not select unwritable objects" do
-    monitor = selector.register(unwritable_subject, :w)
-    expect(selector.select(0)).to be_nil
+    selector.register(unwritable_subject, :w)
+    ready = selector.select(0)
+    expect(ready).to be_nil
   end
 end
 
-RSpec.shared_context "an NIO selectable stream" do
-  let(:selector) { NIO::Selector.new }
+RSpec.shared_context "an NIO selectable stream" do |is_tls13|
+  include_context NIO::Selector
+
   let(:stream)   { pair.first }
   let(:peer)     { pair.last }
 
   it "selects readable when the other end closes" do
-    # hax: this test is broken for OpenSSL sockets
-    skip "broken for SSL ;_;" if peer.is_a? OpenSSL::SSL::SSLSocket
-
     monitor = selector.register(stream, :r)
-    expect(selector.select(0)).to be_nil
+    unless is_tls13
+      expect(selector.select(1)).to be_nil
+    end
 
     peer.close
     # Wait and give the TCP session time to close
@@ -45,14 +58,28 @@ RSpec.shared_context "an NIO selectable stream" do
 end
 
 RSpec.shared_context "an NIO bidirectional stream" do
-  let(:selector) { NIO::Selector.new }
-  let(:stream)   { pair.first }
-  let(:peer)     { pair.last }
+  include_context NIO::Selector
+
+  let(:stream) {pair.first}
+  let(:peer) {pair.last}
 
   it "selects readable and writable" do
-    monitor = selector.register(readable_subject, :rw)
-    selector.select(0) do |m|
-      expect(m.readiness).to eq(:rw)
+    selector.register(readable_subject, :rw)
+
+    selector.select(1) do |monitor|
+      expect(monitor.readiness).to eq(:rw)
+    end
+
+    readable_subject.close
+  end
+
+  it "keeps readiness after the selectable has been closed" do
+    selector.register(readable_subject, :rw)
+
+    selector.select(1) do |monitor|
+      expect(monitor.readiness).to eq(:rw)
+      readable_subject.close
+      expect(monitor.readiness).to eq(:rw)
     end
   end
 end

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: nio4r
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 2.5.3
 platform: ruby
 authors:
 - Tony Arcieri
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-01-31 00:00:00.000000000 Z
+date: 2020-09-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -25,7 +25,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -38,54 +38,62 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: New IO for Ruby
+description: Cross-platform asynchronous I/O primitives for scalable network clients
+  and servers. Inspired by the Java NIO API, but simplified for ease-of-use.
 email:
-- tony.arcieri@gmail.com
+- bascule@gmail.com
 executables: []
 extensions:
 - ext/nio4r/extconf.rb
 extra_rdoc_files: []
 files:
+- ".github/workflows/workflow.yml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
-- ".rubocop_todo.yml"
-- ".travis.yml"
 - CHANGES.md
 - Gemfile
-- LICENSE.txt
+- Guardfile
 - README.md
 - Rakefile
 - examples/echo_server.rb
 - ext/libev/Changes
 - ext/libev/LICENSE
 - ext/libev/README
-- ext/libev/README.embed
 - ext/libev/ev.c
 - ext/libev/ev.h
 - ext/libev/ev_epoll.c
 - ext/libev/ev_kqueue.c
+- ext/libev/ev_linuxaio.c
 - ext/libev/ev_poll.c
 - ext/libev/ev_port.c
 - ext/libev/ev_select.c
 - ext/libev/ev_vars.h
 - ext/libev/ev_win32.c
 - ext/libev/ev_wrap.h
-- ext/libev/test_libev_win32.c
+- ext/nio4r/bytebuffer.c
 - ext/nio4r/extconf.rb
 - ext/nio4r/libev.h
 - ext/nio4r/monitor.c
 - ext/nio4r/nio4r.h
 - ext/nio4r/nio4r_ext.c
+- ext/nio4r/org/nio4r/ByteBuffer.java
+- ext/nio4r/org/nio4r/Monitor.java
 - ext/nio4r/org/nio4r/Nio4r.java
+- ext/nio4r/org/nio4r/Selector.java
 - ext/nio4r/selector.c
 - lib/nio.rb
+- lib/nio/bytebuffer.rb
 - lib/nio/monitor.rb
 - lib/nio/selector.rb
 - lib/nio/version.rb
 - logo.png
 - nio4r.gemspec
+- rakelib/extension.rake
+- rakelib/rspec.rake
+- rakelib/rubocop.rake
 - spec/nio/acceptables_spec.rb
+- spec/nio/bytebuffer_spec.rb
 - spec/nio/monitor_spec.rb
 - spec/nio/selectables/pipe_spec.rb
 - spec/nio/selectables/ssl_socket_spec.rb
@@ -94,14 +102,16 @@ files:
 - spec/nio/selector_spec.rb
 - spec/spec_helper.rb
 - spec/support/selectable_examples.rb
-- tasks/extension.rake
-- tasks/rspec.rake
-- tasks/rubocop.rake
-homepage: https://github.com/celluloid/nio4r
+homepage: https://github.com/socketry/nio4r
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  bug_tracker_uri: https://github.com/socketry/nio4r/issues
+  changelog_uri: https://github.com/socketry/nio4r/blob/master/CHANGES.md
+  documentation_uri: https://www.rubydoc.info/gems/nio4r/2.5.3
+  source_code_uri: https://github.com/socketry/nio4r/tree/v2.5.3
+  wiki_uri: https://github.com/socketry/nio4r/wiki
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -109,20 +119,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
-summary: NIO provides a high performance selector API for monitoring IO objects
+summary: New IO for Ruby
 test_files:
 - spec/nio/acceptables_spec.rb
+- spec/nio/bytebuffer_spec.rb
 - spec/nio/monitor_spec.rb
 - spec/nio/selectables/pipe_spec.rb
 - spec/nio/selectables/ssl_socket_spec.rb