about summary refs log tree commit homepage
path: root/lib
DateCommit message (Collapse)
2011-01-20ev_core: simplify setup steps
ev_core is always loaded after forking, so eliminate the need for extra setup steps for each concurrency model that uses it
2011-01-20merge rack_input into process_client
It turns out to be less-used than previous anticipated, so there's no point in having yet another module.
2011-01-20ev_core: localize 413 error constant
It's the only place we ever use it
2011-01-20remove unused 416 error constants/exceptions
We handle that locally in rainbows/response now
2011-01-20dev_fd_response: garbage reduction
Constant strings mean the runtime won't have to allocate new objects all the time since GC is currently the biggest performance problem of Ruby 1.9.x in my experience.
2011-01-19dev_fd_response: do not send chunks to 1.0 clients
chunked Transfer-Encoding is only valid for HTTP/1.1
2011-01-19remove support for X-Rainbows-* headers
We guarantee the Rack env will exist for the duration of the request/response cycle, so we can just tweak "rainbows.autochunk".
2011-01-19initial edge-triggered epoll model
Coolio and EventMachine only use level-triggered epoll, but being Rainbows!, we live on the EDGE!
2011-01-17ev_core: reuse buffer to avoid GC thrashing
Single-threaded concurrency models can reuse a single buffer to avoid thrashing memory and causing unnecessary GC activity.
2011-01-11Rainbows! 3.0.0 - serving the fastest apps to slow clients faster! v3.0.0
There is one incompatible change: We no longer assume application authors are crazy and use strangely-cased headers for "Content-Length", "Transfer-Encoding", and "Range". This allows us to avoid the case-insensitivity of Rack::Utils::HeaderHash for a speed boost on the few apps that already serve thousands of requests/second per-worker. :Coolio got "async.callback" support like :EventMachine, but it currently lacks EM::Deferrables which would allow us to call "succeed"/"fail" callbacks. This means only one-shot response writes are supported. There are numerous internal code cleanups and several bugfixes for handling partial static file responses.
2011-01-11event_machine: buffer reads when waiting for async.callback
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
2011-01-11event_machine/client: rename ivar for consistency with Coolio
Both use @deferred to refer to the state where there's a deferred response body in the queue.
2011-01-11event_machine/client: remove unused :body accessor
Nobody uses it anymore
2011-01-11coolio: enable async.callback for one-shot body responses
The lack of an equivlent to EM::Deferrable prevents us from doing streaming/trickling responses, but a one-shot body should work fine for Coolio and generating dynamic responses.
2011-01-07rainbows/coolio/client: set LOOP constant in module
It's more natural and easier to maintain this way since Coolio::Client is always lazy loaded.
2011-01-07coolio/client: small optimizations
* lazy load uncommon classes: StreamFile, Response{Chunk,}Pipe * remove needless rainbows/coolio/sendfile module since we're lazily loaded now along with the rest of rainbows/coolio/client and only in the worker.
2011-01-07coolio_thread_*: lazy load Rainbows::Coolio::Client
We don't want that loaded in the parent process since we want config reloadability.
2011-01-07event_machine: fold write_response back into client
No point in having too many modules to search around (for both hackers and the runtime).
2011-01-07event_machine: cleanup async logic
Since we support keepalive now, setting @state can be harmful and the comment is out-of-date.
2011-01-07ev_core: small organization cleanup
We want to put all constants in one place.
2011-01-07more consistent use/avoidance of HeaderHash
Rack::Utils::HeaderHash is still expensive, so avoid forcing it on users since we can assume app/library authors use normally-cased HTTP headers.
2011-01-07favor Hash#include? for some existence checks
Hash#[] is slightly slower on the miss case due to calling Hash#default (but faster for the hit case, probably because it is inlined in 1.9).
2011-01-07response: do not skip Status header set by app
Rack::Lint already stops apps from using it. If a developer insists on it, then users who inspect their HTTP headers can point and laugh at them for not using Rack::Lint!
2011-01-07response: fix skipping of Status: header from app
We already set a Status: header by default for compatibility with some existing, broken libraries out there.
2011-01-07ev_core: garbage reduction with const strings
Reading headers is common and we don't want to create new String objects (even if they're tiny or copy-on-write) for the GC to munch on.
2011-01-06event_machine: refactor async.callback for keepalive
async.callback will be useful with Coolio (and more!) soon, so ensure it works as well as the rest of Rainbows!
2011-01-06event_machine: factor out async.callback handling
This will allow Coolio to use it, too.
2011-01-06minor cleanups following state cleanups
We noticed a few more things that could be cleaned up after the last commit.
2011-01-06eliminate G constant and just use the Rainbows! module
Code organization is hard :<
2011-01-06rainbows.rb: unindent
2011-01-06eliminate timed_read module
No need to split it out when there's only a single class using it.
2011-01-06simplify keepalive_timeout accounting
Easier just to use an instance variable
2011-01-05disable Nagle's algorithm by default
Nagle's algorithm is harmful with the write-write-read sequence during keepalive, so we disable it performance for users using keepalive. We always write headers with a separate write because Rack response bodies may not always be ready for writing when headers are. This requires Unicorn 3.3.0
2011-01-05simplify Rainbows.max_bytes implementation
Yes, I'm still learning Ruby.
2011-01-05response: use optimized httpdate implementation
Believe it or not, Time#httpdate showed up at the top of my profiler output for the past couple of years now. I guess that's what happens when all HTTP applications I write are less complex than Rack::Lobster :P
2011-01-05response: allow normal Hash for crafting Range headers
HeaderHash is quite expensive, and Rack::File currently uses a regular Ruby Hash with properly-cased headers the same way they're presented in rfc2616.
2011-01-05send proper 416 responses
416 responses without a body should respond with a zero Content-Length and a Content-Range that allows clients to specify a proper range in the future. rfc2616, section 14.16 says: > A server sending a response with status code 416 (Requested > range not satisfiable) SHOULD include a Content-Range field > with a byte-range- resp-spec of "*". The instance-length > specifies the current length of the selected resource.
2011-01-04writer_thread_pool: remove unnecesary debug messages
Oops
2011-01-04prefer Hash#merge! to Hash#update for consistency
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.
2011-01-04globally refactor Range handling for responses
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.
2011-01-04coolio: rename deferred_response => response_pipe
For consistency with the EventMachine code
2011-01-04event_machine: cleanup response_pipe
No need to pass unnecessary variables to response_pipe, just let the client handle it all.
2011-01-04refactor response sendfile body handling for easier debugging
Unique method names makes it easier to follow code and determine where our methods come from.
2011-01-04simplify per-client keepalive state checks
This lets us simplify repetitive checks worry less about properly maintaining/closing client connections for each concurrency model we support.
2011-01-04coolio/master: small garbage reduction
Creating unnecessary string objects for every response is not a good idea.
2011-01-04return 206 status for partial sendfile responses
Although curl did not complain, 206 is the correct error code for partial HTTP responses.
2011-01-04coolio_thread_*: fix 416 response handling
After beefing up and enabling byte range tests for "sendfile" (and no just IO.copy_stream), we noticed threaded-Coolio variants did not handle invalid byte ranges correctly.
2010-12-29Rainbows! 2.1.0 - Cool.io, bugfixes and more!
Cool.io (new version of Rev) support is explicitly added (it always worked before). ":Coolio" may be used in place of ":Rev" anywhere in your Rainbows! config file. There is a new "keepalive_requests" config directive to limit the number of requests a single connection may make (default: 100, same as nginx). This may be useful for better load-balancing characteristics. The old "Rev" prefixes remain supported as long as Cool.io remains compatible with Rev (likely forever). Bug fixes: * Rainbows::ThreadTimeout middleware with multiple clients * large, pipelined upload errors with Revactor+Coolio(Rev) * high CPU usage for maintaining idle keepalive on *Fiber* * needless ThreadPool wakeups * request env prematurely cleared keepalive requests, breaking some middlewares such as Clogger. * "close" not called on body if wrapper and sendfile used together Various code cleanups, and our RDoc website is JavaScript-free. See the ChangeLog or git for all changes.
2010-12-28complete Rev => Coolio renaming
We use Cool.io internally everywhere now, but preserve Rev-based models for anybody using them.
2010-12-28several response body#close fixes
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.