class Puma::Reactor

def run_internal

This calculation happens in `calculate_sleep`.
will be set to be equal to the amount of time it will take for the next timeout to occur.
Once all the timeouts have been processed, the next duration of the `NIO::Selector#select` sleep

This behavior loops until all the objects that have timed out have been removed.

that watches for new data.
Then its connection is closed, and the object is removed from the `sockets` array
the client object is removed from the timeout array, a 408 response is written.
the first element in the `@timeout` array has exceed its allowed time. If so,
any requests that have "timed out". At the end of the loop it's checked to see if
periodically "time out" of the sleep. One of the functions of this is to check for
In addition to being woken via a write to one of the sockets the `NIO::Selector#select` will

## Time Out Case

passed to the thread pool.
wake up the `NIO::Selector#select` and it can again be checked to see if it's ready to be
again. When the client sends more data to the socket the `Puma::Client` object will
If the request body is not present then nothing will happen, and the loop will iterate

via `@app_pool << c`. The `Puma::Client` is then removed from the `sockets` array.
can pick up the request and begin to execute application logic. This is done
then the request is passed off to the `@app_pool` thread pool so that a "worker thread"
the `Puma::Client#try_to_finish` method. If the full request has been sent,
the `@ready` pipe, so the reactor checks to see if it has the full header and body with
Each element in the first entry is iterated over. The `Puma::Client` object is not

`ready` output looks like this: `[[#], [], []]`.
the `NIO::Selector#select` is immediately able to "wake" and read from the `Puma::Client`. At this point the
Since the `Puma::Client` in this example has data that has not been read yet,

to the `@ready` IO object. For example: `[#, #]`.
The while then loop continues to iterate again, but now the `sockets` array contains a `Puma::Client` instance in addition
the reactor sees that it's a `"*"` value and the reactor adds the contents of `@input` into the `sockets` array.
If there was a trigger event, then one byte of `@ready` is read into memory. In the case of the first request,

is the same as the `@ready` input pipe, then we know that there was a `trigger` event.
The `reads` variable is iterated through. In the case that the object

is saved as a `reads` variable.
first IO object is the `@ready` object. This first array `[#]`
variable returns an array of arrays that looks like `[[#], [], []]` where the
When `@trigger` is written-to, the loop "wakes" and the `ready`
to whatever "woke" it up. On the very first loop, the only thing in `sockets` is `@ready`.
When that happens, the internal loop stops blocking at `NIO::Selector#select` and returns a reference

Next the `@ready` pipe is "woken" by writing a string of `"*"` to `@trigger`.
When the `add` method is called, an instance of `Puma::Client` is added to the `@input` array.

## When a request is added:

will break on `NIO::Selector#select` and return an array.
connected to `@trigger` object. When `@trigger` is written to, then the loop
array at first is the `@ready` IO object, which is the read end of a pipe
loop, waiting on the `sockets` array objects. The only object in this
Until a request is added via the `add` method this method will internally 
def run_internal
  monitors = @monitors
  selector = @selector
  while true
    begin
      ready = selector.select @sleep_for
    rescue IOError => e
      Thread.current.purge_interrupt_queue if Thread.current.respond_to? :purge_interrupt_queue
      if monitors.any? { |mon| mon.value.closed? }
        STDERR.puts "Error in select: #{e.message} (#{e.class})"
        STDERR.puts e.backtrace
        monitors.reject! do |mon|
          if mon.value.closed?
            selector.deregister mon.value
            true
          end
        end
        retry
      else
        raise
      end
    end
    if ready
      ready.each do |mon|
        if mon.value == @ready
          @mutex.synchronize do
            case @ready.read(1)
            when "*"
              @input.each do |c|
                mon = nil
                begin
                  begin
                    mon = selector.register(c, :r)
                  rescue ArgumentError
                    # There is a bug where we seem to be registering an already registered
                    # client. This code deals with this situation but I wish we didn't have to.
                    monitors.delete_if { |submon| submon.value.to_io == c.to_io }
                    selector.deregister(c)
                    mon = selector.register(c, :r)
                  end
                rescue IOError
                  # Means that the io is closed, so we should ignore this request
                  # entirely
                else
                  mon.value = c
                  @timeouts << mon if c.timeout_at
                  monitors << mon
                end
              end
              @input.clear
              @timeouts.sort! { |a,b| a.value.timeout_at <=> b.value.timeout_at }
              calculate_sleep
            when "c"
              monitors.reject! do |submon|
                if submon.value == @ready
                  false
                else
                  submon.value.close
                  begin
                    selector.deregister submon.value
                  rescue IOError
                    # nio4r on jruby seems to throw an IOError here if the IO is closed, so
                    # we need to swallow it.
                  end
                  true
                end
              end
            when "!"
              return
            end
          end
        else
          c = mon.value
          # 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 mon
            end
          end
          begin
            if c.try_to_finish
              @app_pool << c
              clear_monitor mon
            end
          # Don't report these to the lowlevel_error handler, otherwise
          # will be flooding them with errors when persistent connections
          # are closed.
          rescue ConnectionError
            c.write_error(500)
            c.close
            clear_monitor mon
          # SSL handshake failure
          rescue MiniSSL::SSLError => e
            @server.lowlevel_error(e, c.env)
            ssl_socket = c.io
            begin
              addr = ssl_socket.peeraddr.last
            # EINVAL can happen when browser closes socket w/security exception
            rescue IOError, Errno::EINVAL
              addr = "<unknown>"
            end
            cert = ssl_socket.peercert
            c.close
            clear_monitor mon
            @events.ssl_error @server, addr, cert, e
          # The client doesn't know HTTP well
          rescue HttpParserError => e
            @server.lowlevel_error(e, c.env)
            c.write_error(400)
            c.close
            clear_monitor mon
            @events.parse_error @server, c.env, e
          rescue StandardError => e
            @server.lowlevel_error(e, c.env)
            c.write_error(500)
            c.close
            clear_monitor mon
          end
        end
      end
    end
    unless @timeouts.empty?
      @mutex.synchronize do
        now = Time.now
        while @timeouts.first.value.timeout_at < now
          mon = @timeouts.shift
          c = mon.value
          c.write_error(408) if c.in_data_phase
          c.close
          clear_monitor mon
          break if @timeouts.empty?
        end
        calculate_sleep
      end
    end
  end
end