diff --git a/lib/puma/reactor.rb b/lib/puma/reactor.rb index a6245f52fb..0d419cfd0c 100644 --- a/lib/puma/reactor.rb +++ b/lib/puma/reactor.rb @@ -24,7 +24,7 @@ module Puma # which stores it in an array and waits for any of the connections to be ready for reading. # # The waiting/wake up is performed with nio4r, which will use the apropriate backend (libev, Java NIO or - # just plain IO#select). The call to `NIO::Selector#select` (hereinafter `select()`) will "wake up" and + # just plain IO#select). The call to `NIO::Selector#select` will "wake up" and # return the references to any objects that caused it to "wake". The reactor # then loops through each of these request objects, and sees if they're complete. If they # have a full header and body then the reactor passes the request to a thread pool. @@ -74,14 +74,14 @@ def initialize(server, app_pool) # loop, waiting on the `sockets` array objects. The only object in this # array at first is the `@ready` IO object, which is the read end of a pipe # connected to `@trigger` object. When `@trigger` is written to, then the loop - # will break on `select()` and return an array. + # will break on `NIO::Selector#select` and return an array. # # ## When a request is added: # # When the `add` method is called, an instance of `Puma::Client` is added to the `@input` array. # Next the `@ready` pipe is "woken" by writing a string of `"*"` to `@trigger`. # - # When that happens, the internal loop stops blocking at `select()` and returns a reference + # When that happens, the internal loop stops blocking at `NIO::Selector#select` and returns a reference # to whatever "woke" it up. On the very first loop, the only thing in `sockets` is `@ready`. # When `@trigger` is written-to, the loop "wakes" and the `ready` # variable returns an array of arrays that looks like `[[#], [], []]` where the @@ -97,7 +97,7 @@ def initialize(server, app_pool) # to the `@ready` IO object. For example: `[#, #]`. # # Since the `Puma::Client` in this example has data that has not been read yet, - # the `select()` is immediately able to "wake" and read from the `Puma::Client`. At this point the + # the `NIO::Selector#select` is immediately able to "wake" and read from the `Puma::Client`. At this point the # `ready` output looks like this: `[[#], [], []]`. # # Each element in the first entry is iterated over. The `Puma::Client` object is not @@ -109,12 +109,12 @@ def initialize(server, app_pool) # # If the request body is not present then nothing will happen, and the loop will iterate # again. When the client sends more data to the socket the `Puma::Client` object will - # wake up the `select()` and it can again be checked to see if it's ready to be + # wake up the `NIO::Selector#select` and it can again be checked to see if it's ready to be # passed to the thread pool. # # ## Time Out Case # - # In addition to being woken via a write to one of the sockets the `select()` will + # In addition to being woken via a write to one of the sockets the `NIO::Selector#select` will # periodically "time out" of the sleep. One of the functions of this is to check for # any requests that have "timed out". At the end of the loop it's checked to see if # the first element in the `@timeout` array has exceed its allowed time. If so, @@ -124,7 +124,7 @@ def initialize(server, app_pool) # # This behavior loops until all the objects that have timed out have been removed. # - # Once all the timeouts have been processed, the next duration of the `select()` sleep + # Once all the timeouts have been processed, the next duration of the `NIO::Selector#select` sleep # will be set to be equal to the amount of time it will take for the next timeout to occur. # This calculation happens in `calculate_sleep`. def run_internal @@ -320,7 +320,7 @@ def run_in_thread end end - # The `calculate_sleep` sets the value that the `select()` will + # The `calculate_sleep` sets the value that the `NIO::Selector#select` will # sleep for in the main reactor loop when no sockets are being written to. # # The values kept in `@timeouts` are sorted so that the first timeout @@ -351,18 +351,18 @@ def calculate_sleep # object. # # The main body of the reactor loop is in `run_internal` and it - # will sleep on `select()`. When a new connection is added to the + # will sleep on `NIO::Selector#select`. When a new connection is added to the # reactor it cannot be added directly to the `sockets` array, because - # the `select()` will not be watching for it yet. + # the `NIO::Selector#select` will not be watching for it yet. # - # Instead what needs to happen is that `select()` needs to be woken up, + # Instead what needs to happen is that `NIO::Selector#select` needs to be woken up, # the contents of `@input` added to the `sockets` array, and then - # another call to `select()` needs to happen. Since the `Puma::Client` + # another call to `NIO::Selector#select` needs to happen. Since the `Puma::Client` # object can be read immediately, it does not block, but instead returns # right away. # # This behavior is accomplished by writing to `@trigger` which wakes up - # the `select()` and then there is logic to detect the value of `*`, + # the `NIO::Selector#select` and then there is logic to detect the value of `*`, # pull the contents from `@input` and add them to the sockets array. # # If the object passed in has a timeout value in `timeout_at` then