puma 2.2.0 → 8.0.2

data/lib/puma/reactor.rb

@@ -1,162 +1,131 @@
-require 'puma/util'
+# frozen_string_literal: true
 
 module Puma
+  class UnsupportedBackend < StandardError; end
+
+  # Monitors a collection of IO objects, calling a block whenever
+  # any monitored object either receives data or times out, or when the Reactor shuts down.
+  #
+  # The waiting/wake up is performed with nio4r, which will use the appropriate backend (libev,
+  # Java NIO or just plain IO#select). The call to `NIO::Selector#select` will
+  # 'wakeup' any IO object that receives data.
+  #
+  # This class additionally tracks a timeout for every added object,
+  # and wakes up any object when its timeout elapses.
+  #
+  # The implementation uses a Queue to synchronize adding new objects from the internal select loop.
   class Reactor
-    DefaultSleepFor = 5
 
-    def initialize(server, app_pool)
-      @server = server
-      @events = server.events
-      @app_pool = app_pool
+    # @!attribute [rw] reactor_max
+    #   Maximum number of clients in the selector.  Reset with calls to `Server.stats`.
+    attr_accessor :reactor_max
+    attr_reader :reactor_size
+
+    # Create a new Reactor to monitor IO objects added by #add.
+    # The provided block will be invoked when an IO has data available to read,
+    # its timeout elapses, or when the Reactor shuts down.
+    def initialize(backend, &block)
+      require 'nio'
+      valid_backends = [:auto, *::NIO::Selector.backends]
+      unless valid_backends.include?(backend)
+        raise ArgumentError.new("unsupported IO selector backend: #{backend} (available backends: #{valid_backends.join(', ')})")
+      end
 
-      @mutex = Mutex.new
-      @ready, @trigger = Puma::Util.pipe
-      @input = []
-      @sleep_for = DefaultSleepFor
+      @selector = ::NIO::Selector.new(NIO::Selector.backends.delete(backend))
+      @input = Queue.new
       @timeouts = []
-
-      @sockets = [@ready]
+      @block = block
+      @reactor_size = 0
+      @reactor_max = 0
     end
 
-    def run
-      sockets = @sockets
-
-      while true
-        ready = IO.select sockets, nil, nil, @sleep_for
-
-        if ready and reads = ready[0]
-          reads.each do |c|
-            if c == @ready
-              @mutex.synchronize do
-                case @ready.read(1)
-                when "*"
-                  sockets += @input
-                  @input.clear
-                when "c"
-                  sockets.delete_if do |s|
-                    if s == @ready
-                      false
-                    else
-                      s.close
-                      true
-                    end
-                  end
-                when "!"
-                  return
-                end
-              end
-            else
-              # We have to be sure to remove it from the timeout
-              # list or we'll accidentally close the socket when
-              # it's in use!
-              if c.timeout_at
-                @mutex.synchronize do
-                  @timeouts.delete c
-                end
-              end
-
-              begin
-                if c.try_to_finish
-                  @app_pool << c
-                  sockets.delete c
-                end
-
-              # The client doesn't know HTTP well
-              rescue HttpParserError => e
-                c.write_400
-                c.close
-
-                sockets.delete c
-
-                @events.parse_error @server, c.env, e
-              rescue StandardError => e
-                c.write_500
-                c.close
-
-                sockets.delete c
-              end
-            end
-          end
-        end
-
-        unless @timeouts.empty?
-          @mutex.synchronize do
-            now = Time.now
-
-            while @timeouts.first.timeout_at < now
-              c = @timeouts.shift
-              sockets.delete c
-              c.close
-
-              break if @timeouts.empty?
-            end
-
-            calculate_sleep
-          end
+    # Run the internal select loop, using a background thread by default.
+    def run(background=true)
+      if background
+        @thread = Thread.new do
+          Puma.set_thread_name "reactor"
+          select_loop
         end
+      else
+        select_loop
       end
-    ensure
-      @trigger.close
-      @ready.close
     end
 
-    def run_in_thread
-      @thread = Thread.new {
-        while true
-          begin
-            run
-            break
-          rescue StandardError => e
-            STDERR.puts "Error in reactor loop escaped: #{e.message} (#{e.class})"
-            puts e.backtrace
-          end
-        end
-      }
+    # Add a new client to monitor.
+    # The object must respond to #timeout and #timeout_at.
+    # Returns false if the reactor is already shut down.
+    def add(client)
+      @input << client
+      @selector.wakeup
+      true
+    rescue ClosedQueueError, IOError # Ignore if selector is already closed
+      false
     end
 
-    def calculate_sleep
-      if @timeouts.empty?
-        @sleep_for = DefaultSleepFor
-      else
-        diff = @timeouts.first.timeout_at.to_f - Time.now.to_f
-
-        if diff < 0.0
-          @sleep_for = 0
-        else
-          @sleep_for = diff
-        end
+    # Shutdown the reactor, blocking until the background thread is finished.
+    def shutdown
+      @input.close
+      begin
+        @selector.wakeup
+      rescue IOError # Ignore if selector is already closed
       end
+      @thread&.join
     end
 
-    def add(c)
-      @mutex.synchronize do
-        @input << c
-        @trigger << "*"
+    private
+
+    def select_loop
+      begin
+        until @input.closed? && @input.empty?
+          # Wakeup any registered object that receives incoming data.
+          # Block until the earliest timeout or Selector#wakeup is called.
+          timeout = (earliest = @timeouts.first) && earliest.timeout
+          @selector.select(timeout) do |monitor|
+            wakeup!(monitor.value)
+          end
 
-        if c.timeout_at
-          @timeouts << c
-          @timeouts.sort! { |a,b| a.timeout_at <=> b.timeout_at }
+          # Wakeup all objects that timed out.
+          timed_out = @timeouts.take_while { |client| client.timeout == 0 }
+          timed_out.each { |client| wakeup!(client) }
 
-          calculate_sleep
+          unless @input.empty?
+            until @input.empty?
+              client = @input.pop
+              register(client) if client.io_ok?
+            end
+            @timeouts.sort_by!(&:timeout_at)
+          end
         end
+      rescue StandardError => e
+        STDERR.puts "Error in reactor loop escaped: #{e.message} (#{e.class})"
+        STDERR.puts e.backtrace
+
+        retry
       end
+
+      # Wakeup all remaining objects on shutdown.
+      @timeouts.each(&@block)
+      @selector.close
     end
 
-    # Close all watched sockets and clear them from being watched
-    def clear!
-      begin
-        @trigger << "c"
-      rescue IOError
-      end
+    # Start monitoring the object.
+    def register(client)
+      @selector.register(client.to_io, :r).value = client
+      @reactor_size += 1
+      @reactor_max = @reactor_size if @reactor_max < @reactor_size
+      @timeouts << client
+    rescue ArgumentError
+      # unreadable clients raise error when processed by NIO
     end
 
-    def shutdown
-      begin
-        @trigger << "!"
-      rescue IOError
+    # 'Wake up' a monitored object by calling the provided block.
+    # Stop monitoring the object if the block returns `true`.
+    def wakeup!(client)
+      if @block.call client
+        @selector.deregister client.to_io
+        @reactor_size -= 1
+        @timeouts.delete client
       end
-
-      @thread.join
     end
   end
 end