Date | Commit message (Collapse) |
|
By providing read+readpartial methods
IO.copy_stream behaves slightly differently when operating on
non-IO-subclassed objects nowadays.
Ref:
> * io.c (copy_stream_body): use the arguments without conversion if
> having read, readpartial, and write methods, than conversion by
> to_path method. [ruby-core:68676] [Bug #11015]
|
|
Not all responses are seekable, so do not attempt to pass seek
arguments to them since Ruby may attempt to seek (and fail!).
|
|
We're migrating to a new public-inbox[1] + mailing list
rainbows-public@bogomips.org
[1] http://public-inbox.org/
|
|
unicorn 4.8.x shutdown handling is different and no longer removes
items from the event loop. So we must do that ourselves to enable
graceful shutdown. Otherwise, we'll time out on shutdowns and
the master will forcibly kill us.
|
|
RubyForge is going away, so we must migrate the homepage.
The mailing list will be migrated, soon.
|
|
Internal reworking of unicorn 4.8.0 completely broke us(!).
This commit fixes things, but it means we no longer support
unicorn <= 4.7. Sorry about that.
|
|
There's nothing we can do about these errors due to
network failures and bad clients, either, so do not spew
a backtrace for them.
|
|
Via private communication, I learned of a user using XEpoll
when he should not have been.
|
|
This prevents pathological starvation cases where the user-space
ready-list can be repopulated infinitely. With EPOLLONESHOT,
epoll itself may be used for this task (at a slightly higher
cost) by enabling read/write checks, as the epoll ready-list
preserves event ordering when used with EPOLLONESHOT.
|
|
No need to specify both flags for epoll (confirmed by reading
fs/eventpoll.c in the Linux kernel).
|
|
This DRYs up versioning and makes packages easier to distribute.
|
|
This requires Rack 1.5.x and unicorn 4.6.0 for hijacking
support. Older versions of Rack continue to work fine,
but we must use unicorn 4.6.0 features to support this.
|
|
on_read normally relies on the close checking in on_readable,
but on_deferred_write_complete may be called from on_writable
instead (bypassing the close check of on_readable).
This affects both Epoll and XEpoll users, but only if they
were sending responses via body#to_path and triggering
on_deferred_write_complete.
While we're at it, favor non-recursive want_more instead of
calling on_readable recursively in ev_write_responses to
prevent stack growth.
|
|
This release fixes two EventMachine bugfixes from Lin Jen-Shin
and Mark J. Titorenko. There are also some minor cleanups.
Lin Jen-Shin (1):
event_machine: avoid close on deferred response
Mark J. Titorenko (1):
event_machine: join reactor_thread if it is already running
Eric Wong (2):
event_machine: cleanup confusing assignment
t/GNUmakefile: cleanup test dependencies
|
|
...rather than falling through worker_loop
Prior to the application of this patch, if an EventMachine
reactor_thread has already been started elsewhere before the
worker_loop is entered, the worker_loop exits as a second call
to EM.run does not block the current thread.
This patch causes the worker_loop thread to join the
reactor_thread if it is running.
[ew: commit message formatting]
Signed-off-by: Eric Wong <normalperson@yhbt.net>
|
|
|
|
close_connection_after_writing only if not deferred, as in
cool.io
Deferred responses may buffer more data down the line, so
keep the connection alive if we have a deferred response
body.
[ew: clear @deferred when we really want to quit,
updated commit message]
Acked-by: Eric Wong <normalperson@yhbt.net>
|
|
One bugfix allows stream(:keep_open) in Sinatra to work
properly.
Thanks to W. Andrew Loe III for the informative bug report
and reproducible test case.
ref: http://mid.gmane.org/CA+-9oNd1EFqsniPkkPTwu5opTCinbM7-2KHoXov7+y3LE4s4Tg@mail.gmail.com
|
|
Calling body.close in the normal write_response() code path
is incorrect, and only worked out of sheer luck with
Cramp and async_sinata.
This change allows stream(:keep_open) in Sinatra to work
properly.
Thanks to W. Andrew Loe III for the informative bug report
and reproducible test case.
ref: http://mid.gmane.org/CA+-9oNd1EFqsniPkkPTwu5opTCinbM7-2KHoXov7+y3LE4s4Tg@mail.gmail.com
|
|
Fiber-based concurrency options avoids negative sleep
intervals. Thanks to Lin Jen-Shin for pointing this out.
|
|
Also clarify the code while we're at it.
Thanks to Lin Jen-Shin for pointing this out.
ref: http://mid.gmane.org/CAA2_N1unOXb7Z4Jr8oKoSLu266O9Ko4o=oWzAcMA1w3=9X74KA@mail.gmail.com
|
|
For epoll/Cool.io-based concurrency models, shutdown() is now
used to timeout keepalive clients to avoid race conditions.
Minor documentation improvements.
|
|
Again, for the one thousandth time, timing out threads is very
tricky business :<
|
|
Triggering Errno::EBADF is tricky in multithreaded situations
due to possible race conditions and yet-to-be discovered bugs.
shutdown(2) is also safe against apps the fork() internally but
do not execve(2) nor set FD_CLOEXEC.
n.b. calling fork() after pthreads are spawned may not be safe
on all platforms w.r.t. malloc, but /is/ the case for glibc on
GNU/Linux.
Follow-up-to: commit a5b987619f4b793203f6a50e424fe98c5b0794ba
|
|
Triggering Errno::EBADF is tricky in multithreaded situations
due to possible race conditions and yet-to-be discovered bugs.
shutdown(2) is also safe against apps the fork() internally but
do not execve(2) nor set FD_CLOEXEC.
n.b. calling fork() after pthreads are spawned may not be safe
on all platforms w.r.t. malloc, but /is/ the case for glibc on
GNU/Linux.
|
|
Array#pop can be significantly faster than Array#shift on large
arrays (especially since we push into the Array). This is
because Array#shift needs to shift all elements in the array,
and Array#pop only needs to shorten the array by one element.
The Fiber stack may also be hotter in CPU caches when we choose
the most-frequently used stack.
|
|
unicorn 4.3.x now calls shutdown() explicitly on the socket,
so we can't just rely on a dup()-ed FD to keep a socket around.
|
|
Found with rdoc-spellcheck
|
|
Telling the user worker_connections=50 when using the Base
concurrency model is misleading.
|
|
This release fixes a potential reentrancy deadlock when
using the default logger from the Ruby standard library.
|
|
If any combination of SIGQUIT and SIGUSR1 are sent to a
Rainbows! worker in a /very/ short period of time, the Mutex
used by the default Logger implementation may deadlock since
Mutex synchronization is not reentrant-safe.
Users of alternative logger implementations (or monkey-patched
ones) are possibly not affected. Users of the logger_mp_safe.rb
monkey-patch distributed[1] with unicorn are not affected.
[1] http://unicorn.bogomips.org/examples/logger_mp_safe.rb
|
|
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...
|