nio4r 0.2.0 → 2.7.5

data/lib/nio/bytebuffer.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2016, by Upekshe Jayasekera.
+# Copyright, 2016-2017, by Tony Arcieri.
+# Copyright, 2020, by Thomas Dziedzic.
+# Copyright, 2023, by Samuel Williams.
+
+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,13 +1,102 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2011-2018, by Tony Arcieri.
+# Copyright, 2015, by Upekshe Jayasekera.
+# Copyright, 2015, by Vladimir Kochnev.
+# Copyright, 2018-2023, by Samuel Williams.
+# Copyright, 2019-2020, by Gregory Longtin.
+
 module NIO
   # Monitors watch IO objects for specific events
   class Monitor
-    attr_reader :io, :interests
+    attr_reader :io, :interests, :selector
     attr_accessor :value, :readiness
 
-    # :nodoc
-    def initialize(io, interests)
-      @io, @interests = io, interests
-      @closed = false
+    # :nodoc:
+    def initialize(io, interests, selector)
+      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
+
+          raise TypeError, "can't convert #{io.class} into IO" unless io.is_a? IO
+        end
+      end
+
+      @io        = io
+      @interests = interests
+      @selector  = selector
+      @closed    = false
+    end
+
+    # 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)
+      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?
@@ -19,14 +108,17 @@ module NIO
     def writable?
       readiness == :w || readiness == :rw
     end
-    alias_method :writeable?, :writable?
+    alias writeable? writable?
 
     # Is this monitor closed?
-    def closed?; @closed; end
+    def closed?
+      @closed
+    end
 
     # Deactivate this monitor
-    def close
+    def close(deregister = true)
       @closed = true
+      @selector.deregister(io) if deregister
     end
   end
 end

data/lib/nio/selector.rb

@@ -1,8 +1,36 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2011-2017, by Tony Arcieri.
+# Copyright, 2012, by Logan Bowers.
+# Copyright, 2013, by Sadayuki Furuhashi.
+# Copyright, 2013, by Stephen von Takach.
+# Copyright, 2013, by Tim Carey-Smith.
+# Copyright, 2013, by Ravil Bayramgalin.
+# Copyright, 2014, by Sergey Avseyev.
+# Copyright, 2014, by John Thornton.
+# Copyright, 2015, by Vladimir Kochnev.
+# Copyright, 2015, by Upekshe Jayasekera.
+# Copyright, 2019-2020, by Gregory Longtin.
+# Copyright, 2020-2021, by Joao Fernandes.
+# Copyright, 2023, by Samuel Williams.
+
+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 [:ruby, nil].include?(backend)
+
       @selectables = {}
       @lock = Mutex.new
 
@@ -11,17 +39,40 @@ 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
+    # * :linuxaio - libev w\ Linux AIO io_submit (experimental)
+    # * :io_uring - libev w\ Linux io_uring (experimental)
+    # * :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
-        raise ArgumentError, "this IO is already registered with the selector" if @selectables[io]
+        raise IOError, "selector is closed" if closed?
+
+        monitor = @selectables[io]
+        raise ArgumentError, "already registered as #{monitor.interests.inspect}" if monitor
 
-        monitor = Monitor.new(io, interest)
-        @selectables[io] = monitor
+        monitor = Monitor.new(io, interest, self)
+        @selectables[monitor.io] = monitor
 
         monitor
       end
@@ -30,78 +81,79 @@ module NIO
     # Deregister the given IO object from the selector
     def deregister(io)
       @lock.synchronize do
-        monitor = @selectables.delete io
-        monitor.close if monitor
+        monitor = @selectables.delete IO.try_convert(io)
+        monitor.close(false) if monitor && !monitor.closed?
         monitor
       end
     end
 
     # Is the given IO object registered with the selector?
     def registered?(io)
-      @lock.synchronize { @selectables.has_key? io }
+      @lock.synchronize { @selectables.key? io }
     end
 
     # Select which monitors are ready
     def select(timeout = nil)
+      selected_monitors = Set.new
+
       @lock.synchronize do
-        readers, writers = [@wakeup], []
+        readers = [@wakeup]
+        writers = []
 
         @selectables.each do |io, monitor|
           readers << io if monitor.interests == :r || monitor.interests == :rw
           writers << io if monitor.interests == :w || monitor.interests == :rw
+          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
 
-        results = []
         ready_readers.each do |io|
           if io == @wakeup
             # Clear all wakeup signals we've received by reading them
             # Wakeups should have level triggered behavior
-            begin
-              @wakeup.read_nonblock(1024)
-
-              # Loop until we've drained all incoming events
-              redo
-            rescue Errno::EWOULDBLOCK
-            end
-
-            return
+            @wakeup.read(@wakeup.stat.size)
           else
             monitor = @selectables[io]
             monitor.readiness = :r
-            results << monitor
+            selected_monitors << monitor
           end
         end
 
-        ready_readwriters = ready_readers & ready_writers
-        ready_writers = ready_writers - ready_readwriters
-
-        [[ready_writers, :w], [ready_readwriters, :rw]].each do |ios, readiness|
-          ios.each do |io|
-            monitor = @selectables[io]
-            monitor.readiness = readiness
-            results << monitor
-          end
+        ready_writers.each do |io|
+          monitor = @selectables[io]
+          monitor.readiness = monitor.readiness == :r ? :rw : :w
+          selected_monitors << monitor
         end
-
-        results
       end
-    end
 
-    # Select for ready monitors, successively yielding each one in a block
-    def select_each(timeout = nil, &block)
-      selected = select(timeout)
-      return unless selected
-      selected.each(&block)
-      selected.size
+      if block_given?
+        selected_monitors.each { |m| yield m }
+        selected_monitors.size
+      else
+        selected_monitors.to_a
+      end
     end
 
-    # Wake up other threads waiting on this selector
+    # Wake up a thread that's in the middle of selecting on this selector, if
+    # any such thread exists.
+    #
+    # Invoking this method more than once between two successive select calls
+    # has the same effect as invoking it just once. In other words, it provides
+    # level-triggered behavior.
     def wakeup
       # Send the selector a signal in the form of writing data to a pipe
-      @waker << "\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,13 +162,27 @@ 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
 
     # Is this selector closed?
-    def closed?; @closed end
+    def closed?
+      @closed
+    end
+
+    def empty?
+      @selectables.empty?
+    end
   end
 end

data/lib/nio/version.rb

@@ -1,3 +1,10 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2011-2018, by Tony Arcieri.
+# Copyright, 2018-2024, by Samuel Williams.
+# Copyright, 2023, by Tsimnuj Hawj.
+
 module NIO
-  VERSION = "0.2.0"
+  VERSION = "2.7.5"
 end

data/lib/nio.rb

@@ -1,5 +1,16 @@
-require 'thread'
-require 'nio/version'
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2011-2017, by Tony Arcieri.
+# Copyright, 2013, by Stephen von Takach.
+# Copyright, 2013, by Per Lundberg.
+# Copyright, 2014, by Marek Kowalcze.
+# Copyright, 2016, by Upekshe Jayasekera.
+# Copyright, 2019-2023, by Samuel Williams.
+# Copyright, 2021, by Jun Jiang.
+
+require "socket"
+require "nio/version"
 
 # New I/O for Ruby
 module NIO
@@ -7,24 +18,44 @@ module NIO
   # * select: in pure Ruby using Kernel.select
   # * libev: as a C extension using libev
   # * java: using Java NIO
-  def self.engine; ENGINE end
+  def self.engine
+    ENGINE
+  end
+
+  def self.pure?(env = ENV)
+    # The user has explicitly opted in to non-native implementation:
+    if env["NIO4R_PURE"] == "true"
+      return true
+    end
+
+    # Native Ruby on Windows is not supported:
+    if (Gem.win_platform? && !defined?(JRUBY_VERSION))
+      return true
+    end
+
+    # M1 native extension is crashing on M1 (arm64):
+    # if RUBY_PLATFORM =~ /darwin/ && RUBY_PLATFORM =~ /arm64/
+    #   return true
+    # end
+
+    return false
+  end
 end
 
-if ENV["NIO4R_PURE"]
-  require 'nio/monitor'
-  require 'nio/selector'
-  NIO::ENGINE = 'select'
+if NIO.pure?
+  require "nio/monitor"
+  require "nio/selector"
+  require "nio/bytebuffer"
+  NIO::ENGINE = "ruby"
 else
+  require "nio4r_ext"
+
   if defined?(JRUBY_VERSION)
-    require 'java'
-    require 'nio/jruby/monitor'
-    require 'nio/jruby/selector'
-    NIO::ENGINE = 'java'
+    require "java"
+    require "jruby"
+    org.nio4r.Nio4r.new.load(JRuby.runtime, false)
+    NIO::ENGINE = "java"
   else
-    require 'nio4r_ext'
-    NIO::ENGINE = 'libev'
+    NIO::ENGINE = "libev"
   end
 end
-
-# TIMTOWTDI!!!
-Nio = NIO

data/lib/nio4r.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2023, by Phillip Aldridge.
+# Copyright, 2023, by Samuel Williams.
+
+require_relative "nio"