| Date | Commit message (Collapse) |
|---|
|
We can't possibly keep track of all sub-dependencies,
so only declare primary dependencies until we find
a known problem with a sub-dependency.
|
|
I realize this lock overly covers different versions of
Ruby, but it's simple and we don't need to invoke isolate
too often (we hope).
|
|
It's out and it works, so why not.
|
|
We need to split out Cramp tests to Isolate to a
different path, which sucks, but oh well. Cramp
hasn't had a release in a while...
|
|
async.callback will be useful with Coolio (and more!) soon, so
ensure it works as well as the rest of Rainbows!
|
|
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
|
|
This means we can remove Time.now.httpdate in the next commit
|
|
This is useful for clients that specify a bad range,
we can preserve the connection for them to specify
a good response.
|
|
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.
|
|
It's not appropriate to use AppPool middleware with
these. It was disabled for RevThread*, too.
|
|
Although curl did not complain, 206 is the correct error
code for partial HTTP responses.
|
|
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.
|
|
Tests for checking the Content-Range were totally broken,
but fortunately the code itself works.
|
|
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 will allow servers to limit the number of keepalive
requests that can be made over a single connection to
prevent denial-of-service and also to improve fairness
in load-balancing.
|
|
We still use and define Rev internally, but that's
mostly just manual labor of converting stuff over.
|
|
This requires manual verification :<
|
|
We need to be able to set this with keepalive_timeout
simultaneously.
|
|
We need to ensure the first worker has started and is
running before attempting to signal the reload.
|
|
The worker process may fork before the original process
is killed during daemonization.
|
|
Cool.io is the new name for Rev. We'll continue to support Rev
until Cool.io breaks backwards compatibility. Rev may not be
supported if Cool.io is.
|
|
It still burns CPU at the first sign of doing anything
interesting, so stop it. Ruby 1.9 is the future :P
|
|
Unicorn 3.2.1 gives us an improved HttpParser#next? that
preserves state until the next HttpParser#parse call.
|
|
This was causing unrelated requests to get killed every
+timeout+ seconds, instead of only the ones that were
running too long.
Noticed-by: ghazel@gmail.com
ref:
http://mid.gmane.org/AANLkTi=7OhyTwkHsp_rXU7Gp1PokihiQ9bJigpO-BfN6@mail.gmail.com
|
|
We'll be taking advantage of configurable
client_buffer_body_size soon.
|
|
This was completely overlooked for the Rainbows 2.0.x
releases.
|
|
We use real tabs for indenting shell code since it is not Ruby.
|
|
Large uploads behave differently with regard to buffering,
and there were bugs in the way the Rev and Revactor backends
handled uploads.
|
|
All synchronous models have this fixed in unicorn 3.0.1,
so only Rev and EventMachine-based concurrency models
require code changes.
|
|
Unicorn 3.0.0 is final and released, so we will use it in our
tests
|
|
To avoid denial-of-service attacks, the wrappers need to
intercept requests *before* they hit the memory allocator, so we
need to reimplement the read(all) and gets cases to use
smaller buffers whenever the application does not specify one.
|
|
Kgio 2.0.0 has a superior API and less likely to conflict or
blow up with other applications. Unicorn 3.x requires Kgio 2.x,
too.
|
|
It allows disabling rewindable input and contains
simpler code for upload processing.
|
|
We need to ensure the old worker is really dead before sending
requests after reloading.
|
|
On busy machines, old workers may not shutdown quickly
enough and may still be processing requests.
|
|
For consistency, changed settings are reset back to
their default values if they are removed or commented
out from the config file.
|
|
Unicorn 2.0.0 has CPU wakeup reductions.
|
|
Applications may use wait_readable-aware methods directly
to work with Rainbows!
|
|
We get basic internal API changes from Unicorn,
code simplifications coming next.
|
|
It removes the burden of byte slicing and setting file
descriptor flags. In some cases, we can remove unnecessary
peeraddr calls, too.
|
|
Unicorn 1.1.3 fixes potential race conditions during
SIGUSR1 log reopening.
|
|
Although this behavior is mentioned on the documentation,
this was broken under EventMachine, Rev*, and Revactor.
Furthermore, we set the "Connection: close" header to allow the
client to optimize is handling of non-keepalive connections.
|
|
Rack::Lint uses String#inspect to generate assertion messages
whether or not the assertions are triggered at all.
Unfortunately String#inspect is hilariously slow under 1.9.2
when dealing with odd characters and large strings.
The performance difference is huge:
before: 1m4.386s
after: 0m3.877s
We already have Rack::Lint enabled everywhere else, so removing
this where performance matters most shouldn't hurt us.
|
|
This allows for per-dispatch timeouts similar to (but not exactly)
the way Mongrel (1.1.x) implemented them with threads.
|
|
First off we use an FD_MAP to avoid creating redundant IO
objects which map to the same FD. When that doesn't work, we'll
fall back to trapping Errno::EBADF and IOError where
appropriate.
|
|
Not sure what possessed me to clobber the original
variable set in the parent, but the initial time
for the subshell could be set too late in relation
to the actual server time. So we need to stash the
original time before any HTTP requests were made.
|
|
Due to the synchronous nature of Revactor, we can
be certain sendfile won't overstep the userspace
output buffering done by Rev.
|
|
Our test suite doesn't include facilities for dealing
with temporary directories, yet.
|
|
We may want to try some external libraries for some tests
via RUBYLIB/RUBYOPT while doing development.
|
|
Proxying regular Ruby IO objects while Revactor is in use is
highly suboptimal, so proxy it with an Actor-aware wrapper for
better scheduling.
|