nio4r 1.2.1 → 2.5.3

data/lib/nio.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "thread"
 require "socket"
 require "nio/version"
 
@@ -18,7 +17,8 @@ end
 if ENV["NIO4R_PURE"] == "true" || (Gem.win_platform? && !defined?(JRUBY_VERSION))
   require "nio/monitor"
   require "nio/selector"
-  NIO::ENGINE = "ruby".freeze
+  require "nio/bytebuffer"
+  NIO::ENGINE = "ruby"
 else
   require "nio4r_ext"
 
@@ -26,8 +26,8 @@ else
     require "java"
     require "jruby"
     org.nio4r.Nio4r.new.load(JRuby.runtime, false)
-    NIO::ENGINE = "java".freeze
+    NIO::ENGINE = "java"
   else
-    NIO::ENGINE = "libev".freeze
+    NIO::ENGINE = "libev"
   end
 end

data/lib/nio/bytebuffer.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+module NIO
+  # Efficient byte buffers for performant I/O operations
+  class ByteBuffer
+    include Enumerable
+
+    attr_reader :position, :limit, :capacity
+
+    # Insufficient capacity in buffer
+    OverflowError = Class.new(IOError)
+
+    # Not enough data remaining in buffer
+    UnderflowError = Class.new(IOError)
+
+    # Mark has not been set
+    MarkUnsetError = Class.new(IOError)
+
+    # Create a new ByteBuffer, either with a specified capacity or populating
+    # it from a given string
+    #
+    # @param capacity [Integer] size of buffer in bytes
+    #
+    # @return [NIO::ByteBuffer]
+    def initialize(capacity)
+      raise TypeError, "no implicit conversion of #{capacity.class} to Integer" unless capacity.is_a?(Integer)
+
+      @capacity = capacity
+      clear
+    end
+
+    # Clear the buffer, resetting it to the default state
+    def clear
+      @buffer   = ("\0" * @capacity).force_encoding(Encoding::BINARY)
+      @position = 0
+      @limit    = @capacity
+      @mark     = nil
+
+      self
+    end
+
+    # Set the position to the given value. New position must be less than limit.
+    # Preserves mark if it's less than the new position, otherwise clears it.
+    #
+    # @param new_position [Integer] position in the buffer
+    #
+    # @raise [ArgumentError] new position was invalid
+    def position=(new_position)
+      raise ArgumentError, "negative position given" if new_position < 0
+      raise ArgumentError, "specified position exceeds capacity" if new_position > @capacity
+
+      @mark = nil if @mark && @mark > new_position
+      @position = new_position
+    end
+
+    # Set the limit to the given value. New limit must be less than capacity.
+    # Preserves limit and mark if they're less than the new limit, otherwise
+    # sets position to the new limit and clears the mark.
+    #
+    # @param new_limit [Integer] position in the buffer
+    #
+    # @raise [ArgumentError] new limit was invalid
+    def limit=(new_limit)
+      raise ArgumentError, "negative limit given" if new_limit < 0
+      raise ArgumentError, "specified limit exceeds capacity" if new_limit > @capacity
+
+      @position = new_limit if @position > new_limit
+      @mark = nil if @mark && @mark > new_limit
+      @limit = new_limit
+    end
+
+    # Number of bytes remaining in the buffer before the limit
+    #
+    # @return [Integer] number of bytes remaining
+    def remaining
+      @limit - @position
+    end
+
+    # Does the ByteBuffer have any space remaining?
+    #
+    # @return [true, false]
+    def full?
+      remaining.zero?
+    end
+
+    # Obtain the requested number of bytes from the buffer, advancing the position.
+    # If no length is given, all remaining bytes are consumed.
+    #
+    # @raise [NIO::ByteBuffer::UnderflowError] not enough data remaining in buffer
+    #
+    # @return [String] bytes read from buffer
+    def get(length = remaining)
+      raise ArgumentError, "negative length given" if length < 0
+      raise UnderflowError, "not enough data in buffer" if length > @limit - @position
+
+      result = @buffer[@position...length]
+      @position += length
+      result
+    end
+
+    # Obtain the byte at a given index in the buffer as an Integer
+    #
+    # @raise [ArgumentError] index is invalid (either negative or larger than limit)
+    #
+    # @return [Integer] byte at the given index
+    def [](index)
+      raise ArgumentError, "negative index given" if index < 0
+      raise ArgumentError, "specified index exceeds limit" if index >= @limit
+
+      @buffer.bytes[index]
+    end
+
+    # Add a String to the buffer
+    #
+    # @param str [#to_str] data to add to the buffer
+    #
+    # @raise [TypeError] given a non-string type
+    # @raise [NIO::ByteBuffer::OverflowError] buffer is full
+    #
+    # @return [self]
+    def put(str)
+      raise TypeError, "expected String, got #{str.class}" unless str.respond_to?(:to_str)
+
+      str = str.to_str
+
+      raise OverflowError, "buffer is full" if str.length > @limit - @position
+
+      @buffer[@position...str.length] = str
+      @position += str.length
+      self
+    end
+    alias << put
+
+    # Perform a non-blocking read from the given IO object into the buffer
+    # Reads as much data as is immediately available and returns
+    #
+    # @param [IO] Ruby IO object to read from
+    #
+    # @return [Integer] number of bytes read (0 if none were available)
+    def read_from(io)
+      nbytes = @limit - @position
+      raise OverflowError, "buffer is full" if nbytes.zero?
+
+      bytes_read = IO.try_convert(io).read_nonblock(nbytes, exception: false)
+      return 0 if bytes_read == :wait_readable
+
+      self << bytes_read
+      bytes_read.length
+    end
+
+    # Perform a non-blocking write of the buffer's contents to the given I/O object
+    # Writes as much data as is immediately possible and returns
+    #
+    # @param [IO] Ruby IO object to write to
+    #
+    # @return [Integer] number of bytes written (0 if the write would block)
+    def write_to(io)
+      nbytes = @limit - @position
+      raise UnderflowError, "no data remaining in buffer" if nbytes.zero?
+
+      bytes_written = IO.try_convert(io).write_nonblock(@buffer[@position...@limit], exception: false)
+      return 0 if bytes_written == :wait_writable
+
+      @position += bytes_written
+      bytes_written
+    end
+
+    # Set the buffer's current position as the limit and set the position to 0
+    def flip
+      @limit = @position
+      @position = 0
+      @mark = nil
+      self
+    end
+
+    # Set the buffer's current position to 0, leaving the limit unchanged
+    def rewind
+      @position = 0
+      @mark = nil
+      self
+    end
+
+    # Mark a position to return to using the `#reset` method
+    def mark
+      @mark = @position
+      self
+    end
+
+    # Reset position to the previously marked location
+    #
+    # @raise [NIO::ByteBuffer::MarkUnsetError] mark has not been set (call `#mark` first)
+    def reset
+      raise MarkUnsetError, "mark has not been set" unless @mark
+
+      @position = @mark
+      self
+    end
+
+    # Move data between the position and limit to the beginning of the buffer
+    # Sets the position to the end of the moved data, and the limit to the capacity
+    def compact
+      @buffer[0...(@limit - @position)] = @buffer[@position...@limit]
+      @position = @limit - @position
+      @limit = capacity
+      self
+    end
+
+    # Iterate over the bytes in the buffer (as Integers)
+    #
+    # @return [self]
+    def each(&block)
+      @buffer[0...@limit].each_byte(&block)
+    end
+
+    # Inspect the state of the buffer
+    #
+    # @return [String] string describing the state of the buffer
+    def inspect
+      format(
+        "#<%s:0x%x @position=%d @limit=%d @capacity=%d>",
+        self.class,
+        object_id << 1,
+        @position,
+        @limit,
+        @capacity
+      )
+    end
+  end
+end

data/lib/nio/monitor.rb

@@ -1,19 +1,23 @@
+# frozen_string_literal: true
+
 module NIO
   # Monitors watch IO objects for specific events
   class Monitor
     attr_reader :io, :interests, :selector
     attr_accessor :value, :readiness
 
-    # :nodoc
+    # :nodoc:
     def initialize(io, interests, selector)
-      unless io.is_a?(IO)
-        if IO.respond_to? :try_convert
-          io = IO.try_convert(io)
-        elsif io.respond_to? :to_io
-          io = io.to_io
-        end
+      unless defined?(::OpenSSL) && io.is_a?(::OpenSSL::SSL::SSLSocket)
+        unless io.is_a?(IO)
+          if IO.respond_to? :try_convert
+            io = IO.try_convert(io)
+          elsif io.respond_to? :to_io
+            io = io.to_io
+          end
 
-        fail TypeError, "can't convert #{io.class} into IO" unless io.is_a? IO
+          raise TypeError, "can't convert #{io.class} into IO" unless io.is_a? IO
+        end
       end
 
       @io        = io
@@ -22,14 +26,72 @@ module NIO
       @closed    = false
     end
 
-    # set the interests set
+    # Replace the existing interest set with a new one
+    #
+    # @param interests [:r, :w, :rw, nil] I/O readiness we're interested in (read/write/readwrite)
+    #
+    # @return [Symbol] new interests
     def interests=(interests)
-      fail TypeError, "monitor is already closed" if closed?
-      fail ArgumentError, "bad interests: #{interests}" unless [:r, :w, :rw].include?(interests)
+      raise EOFError, "monitor is closed" if closed?
+      raise ArgumentError, "bad interests: #{interests}" unless [:r, :w, :rw, nil].include?(interests)
 
       @interests = interests
     end
 
+    # Add new interests to the existing interest set
+    #
+    # @param interests [:r, :w, :rw] new I/O interests (read/write/readwrite)
+    #
+    # @return [self]
+    def add_interest(interest)
+      case interest
+      when :r
+        case @interests
+        when :r  then @interests = :r
+        when :w  then @interests = :rw
+        when :rw then @interests = :rw
+        when nil then @interests = :r
+        end
+      when :w
+        case @interests
+        when :r  then @interests = :rw
+        when :w  then @interests = :w
+        when :rw then @interests = :rw
+        when nil then @interests = :w
+        end
+      when :rw
+        @interests = :rw
+      else raise ArgumentError, "bad interests: #{interest}"
+      end
+    end
+
+    # Remove interests from the existing interest set
+    #
+    # @param interests [:r, :w, :rw] I/O interests to remove (read/write/readwrite)
+    #
+    # @return [self]
+    def remove_interest(interest)
+      case interest
+      when :r
+        case @interests
+        when :r  then @interests = nil
+        when :w  then @interests = :w
+        when :rw then @interests = :w
+        when nil then @interests = nil
+        end
+      when :w
+        case @interests
+        when :r  then @interests = :r
+        when :w  then @interests = nil
+        when :rw then @interests = :r
+        when nil then @interests = nil
+        end
+      when :rw
+        @interests = nil
+      else raise ArgumentError, "bad interests: #{interest}"
+      end
+    end
+
     # Is the IO object readable?
     def readable?
       readiness == :r || readiness == :rw

data/lib/nio/selector.rb

@@ -1,10 +1,21 @@
+# frozen_string_literal: true
+
 require "set"
 
 module NIO
   # Selectors monitor IO objects for events of interest
   class Selector
+    # Return supported backends as symbols
+    #
+    # See `#backend` method definition for all possible backends
+    def self.backends
+      [:ruby]
+    end
+
     # Create a new NIO::Selector
-    def initialize
+    def initialize(backend = :ruby)
+      raise ArgumentError, "unsupported backend: #{backend}" unless backend == :ruby
+
       @selectables = {}
       @lock = Mutex.new
 
@@ -13,17 +24,35 @@ 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)
+      unless defined?(::OpenSSL) && io.is_a?(::OpenSSL::SSL::SSLSocket)
+        io = IO.try_convert(io)
+      end
+
       @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 +64,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
@@ -48,6 +77,8 @@ module NIO
 
     # Select which monitors are ready
     def select(timeout = nil)
+      selected_monitors = Set.new
+
       @lock.synchronize do
         readers = [@wakeup]
         writers = []
@@ -58,17 +89,14 @@ module NIO
           monitor.readiness = nil
         end
 
-        ready_readers, ready_writers = Kernel.select readers, writers, [], timeout
-        return unless ready_readers # timeout or wakeup
-
-        selected_monitors = Set.new
+        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 +106,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.size
-        else
-          selected_monitors
-        end
+      if block_given?
+        selected_monitors.each { |m| yield m }
+        selected_monitors.size
+      else
+        selected_monitors.to_a
       end
     end
 
@@ -101,7 +127,16 @@ module NIO
     # level-triggered behavior.
     def wakeup
       # Send the selector a signal in the form of writing data to a pipe
-      @waker.write "\0"
+      begin
+        @waker.write_nonblock "\0"
+      rescue IO::WaitWritable
+        # This indicates the wakeup pipe is full, which means the other thread
+        # has already received many wakeup calls, but not processed them yet.
+        # The other thread will completely drain this pipe when it wakes up,
+        # so it's ok to ignore this exception if it occurs: we know the other
+        # thread has already been signaled to wake up
+      end
+
       nil
     end
 
@@ -110,8 +145,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