Date | Commit message (Collapse) |
|
We cannot trigger on_read events and invoke the HTTP parser and
modify @env while we're waiting for an application to run
async.callback. We also need to clear (and *maybe* re-set)
@deferred if we're writing from async.callback
|
|
Both use @deferred to refer to the state where there's a
deferred response body in the queue.
|
|
Nobody uses it anymore
|
|
No point in having too many modules to search around
(for both hackers and the runtime).
|
|
Since we support keepalive now, setting @state can be
harmful and the comment is out-of-date.
|
|
async.callback will be useful with Coolio (and more!) soon, so
ensure it works as well as the rest of Rainbows!
|
|
This will allow Coolio to use it, too.
|
|
Easier just to use an instance variable
|
|
It's more likely to be in the method cache since Rack::URLMap
uses it and also is more consistent when looking at profiling
output against various concurrency models.
|
|
Rack::Utils::HeaderHash is still very expensive in Rack 1.2,
especially for simple things that we want to run as fast as
possible with minimal interference. HeaderHash is unnecessary
for most requests that do not send Content-Range in responses.
|
|
No need to pass unnecessary variables to response_pipe,
just let the client handle it all.
|
|
This lets us simplify repetitive checks worry less about
properly maintaining/closing client connections for each
concurrency model we support.
|
|
Some middlewares require the Rack env to be preserved all
the way through to close, so we'll ensure all request models
preserve it.
We also need to better response body wrappers/proxies always get
fired properly when returning. IO.copy_stream and "sendfile"
gem users could hit cases where wrappers did not fire properly.
|
|
This should make things easier to find
|
|
EM::FileStreamer writes may be intermingled with the headers
in the subsequent response if we enable processing of the
second pipelined response right away, so wait until the
first response is complete before hitting the second one.
This also avoids potential deep stack recursion in the unlikely
case where too many requests are pipelined.
|
|
Some middlewares such as Clogger rely on wrapping the body
having the close method called on it for logging.
|
|
It's slightly faster as theres no string to parse and also
no garbage format string to be discarded.
|
|
Some applications may not use Response*Pipe and TryDefer at all,
so there's no reason to pollute the runtime with extra nodes to
mark during GC.
|