Date | Commit message (Collapse) |
|
The deprecated Rainbows::HttpResponse class is finally gone
thanks to Pratik Naik. Logging of errors is more consistent
with the changes in unicorn 4.1.0. There are also minor
documentation updates. See the unicorn 4.1.0 release notes
for more details:
http://bogomips.org/unicorn.git/tag/?id=v4.1.0
|
|
It doesn't seem to work at the top of the file...
|
|
Cramp has a homepage and mailing list now, yay!
|
|
The Unicorn.log_error method exists since 4.0.0
|
|
Acked-by: Eric Wong <normalperson@yhbt.net>
|
|
This release includes updates to support WebSockets
under Cramp 0.14 and later. This will be the last
release which supports Cramp 0.13.
There are no changes in this release for non-Cramp
users.
|
|
Oops, testing against new changes against cramp.git here
|
|
This can allow Cramp (and potentially other libraries)
to subclass or implement duck-type compatible versions
of Rainbows::EventMachine::Client.
|
|
There are only some minor cleanups in this release and a bump to
kgio 2.5 to remove the dependency on io/wait. kgio 2.5 or later
is now required (kgio 2.6+ will be required in the next
release).
|
|
Unicorn 4.x already defaults match those of Rainbows!
to favor lower latency instead of lowered bandwidth
usage.
|
|
kgio 2.5 added kgio_wait_*able methods
|
|
Unicorn (> 4.0.1) already handles this for us,
not that it affects many people...
This reverts commit 37c376a9253ed62d134cbb4dbc6eaecc6076c77e.
|
|
This fixes up breakage introduced in commit
905f0ff393629ddb4d70e3dc221b016128c47415 to switch to
kgio for timed, synchronous waiting.
|
|
Since kgio_wait_*able in kgio 2.5 takes an optional timeout
argument, we no longer have to load the extra "io/wait" module.
This saves us a small amount of some memory and also removes the
extra ioctl(FIONREAD) syscall IO#wait enforces.
Like IO#wait in Ruby 1.9.3dev, kgio_wait_readable may use
ppoll() to wait on high-numbered file descriptors as efficiently
as it waits on low-numbered descriptors.
|
|
We can't wait for longer than 68 years.
|
|
Rainbows! now scales to more than 1024 worker processes without
special privileges. To enable this, Rainbows! now depends on
Unicorn 4.x and thus raindrops[1].
client_max_header_size directive is added to limit per-client
memory usage in headers.
An experimental StreamResponseEpoll concurrency option now
exists to buffer outgoing responses without any thread-safe
dependencies. Unlike the rest of Rainbows! which works fine
without nginx, this concurrency option is /only/ supported
behind nginx, even more strongly so than Unicorn itself.
non-nginx LAN clients are NOT supported for this. This relies
on the sleepy_penguin[2] RubyGem (and Linux).
There are some minor bug fixes and cleanups all around. See
"git log v3.4.0.." for details.
[1] http://raindrops.bogomips.org/
[2] http://bogomips.org/sleepy_penguin/
|
|
It hasn't been used in a while, but we kept it for
Zbatery version compatibility.
|
|
Some pipe responses can trigger the on_deferred_write_complete
method without ever re-running the event loop.
This appears to be the result of the occasional t0050 failures.
|
|
Untested, but it should work nowadays...
|
|
This removes the extra per-process file descriptor and
replaces it with Raindrops.
|
|
We no longer need to put all listeners away since
Unicorn uses kgio.
|
|
Lowering this will lower worst-case memory usage and mitigate some
denial-of-service attacks. This should be larger than
client_header_buffer_size.
The default value is carried over from Mongrel and Unicorn.
|
|
Do not encourage their use, really.
|
|
Yes, this concurrency model is our strangest yet.
|
|
We can get away with a single stack frame reduction. Unicorn
itself has more stack reductions, but Rainbows! is further
behind in this area.
|
|
Do not assume middlewares/applications are stupid and blindly
add chunking to responses (we have precedence set by
Rack::Chunked).
|
|
HttpParser#trailers and #headers are actually the same
method, so we'll just continue on.
|
|
It's easier-to-use in some cases.
|
|
Rack::File already sets Content-Range, so don't repeat work
and reparse Content-Length.
|
|
This doesn't use Rainbows::Base so we have no keepalive support
at all. This could eventually be an option for streaming
applications.
|
|
We may not always use Rainbows! :Base since we don't want
keepalive/immediate log reopening in some cases.
|
|
Linux 3.0.0 is just around the corner and of course newer
than 2.6.
|
|
It's better under 1.9.3 (sleepy_penguin 3.0.1 was bogus)
|
|
It's better under 1.9.3
|
|
It should hopefully give this more visibility even though it's
an internal feature.
|
|
We need to trigger a recv() to uncork the response.
This won't affect fairness (much) since all recv()s
are non-blocking and a successful header parse will
put us in the back of the queue.
|
|
Since it's cheap to maintain keepalive clients with EM, we need
a way of disconnecting them in a timely fashion on rare SIGQUIT
events.
|
|
This should enable Kgio "autopush" support for ThreadSpawn,
ThreadPool, XEpollThreadSpawn, and XEpollThreadPool.
(still needs tests)
|
|
In concurrency models long keepalive times are cheap (and thus
more likely to be used), this allows Rainbows! to gracefully
shut down more quickly.
|
|
There's less logic in the server this way and easier
to potentially share code this way.
|
|
io_splice 4.1.1 works around issues with socket
buffers filling up pipe buffers on blocking splice.
See http://lkml.org/lkml/2009/1/13/478 for a better
explanation.
|
|
* improved documentation all around, suggestions/comments to further
improve documentation is greatly welcome at: rainbows-talk@rubyforge.org
* added GPLv3 option to the license (now (Ruby|GPLv2|GPLv3), though
Unicorn is still (Ruby|GPLv2) for now)
* added client_header_buffer_size config directive (default 1K)
* small default header buffer size (16K => 1K) to reduce memory usage,
Rails apps with cookie sessions may want to increase this (~2K)
* all concurrency models default to 50 connections per process
* all concurrency models with a secondary :pool_size parameter also
default to 50 (threads/fibers/whatever)
* RLIMIT_NOFILE and RLIMIT_NPROC are automatically increased if needed
* Rainbows::ThreadTimeout middleware rewritten, still not recommended,
lazy people should be using Unicorn anyways :)
* Several experimental Linux-only edge-triggered epoll options:
XEpollThreadSpawn, XEpollThreadPool, XEpoll, and Epoll.
The latter two were in previous releases but never announced.
These require the "sleepy_penguin", "raindrops", and "sendfile" RubyGems
=== Deprecations
* Rainbows::Fiber::IO* APIs all deprecated, Rainbows! will avoid
having any concurrency model-specific APIs in the future and
also avoid introducing new APIs for applications.
* Fiber-based concurrency models are no longer recommended, they're
too fragile for most apps, use at your own risk (they'll continue to
be supported, however). Linux NPTL + Ruby 1.9 is pretty lightweight
and will be even lighter in Ruby 1.9.3 if you're careful with stack
usage in your C extensions.
|
|
I can't wait until I stop supporting Ruby 1.8
|
|
Hopefully makes things easier to try out.
|
|
The only supported method is Rainbows.sleep in here
|
|
Only needed for Ruby 1.9
|
|
Just close the epoll descriptor, since the sleepy_penguin
epoll_wait wrapper may not return EINTR in the future.
|
|
This allows using IO::Splice.copy_stream from the "io_splice"
RubyGem on recent Linux systems. This also allows users to
disable copy_stream usage entirely and use traditional
response_body.each calls which are compatible with all Rack
servers (to workaround bugs in IO.copy_stream under 1.9.2-p180).
|
|
Finally, we have all methods in configurator and it's
much easier to document!
|
|
It can't be used as middleware for fully-buffering concurrency
models.
|