Date | Commit message (Collapse) |
|
Honestly, these disclaimers should've been there all along;
and should apply to all servers handling multiple clients
within a single process.
|
|
Since EventMachine 1.0.0 in 2012, the EM.defers_finish? API
exists to check for the existence of deferred actions.
Support it if it exists in the running version of EM and
update the note in our SIGNALS document.
Thanks to <alex0375@gmail.com> on the mailing list for bringing
this up:
https://bogomips.org/rainbows-public/CAKwvcL-VH3we4qA1pkNAstTmWvqNA=Rir2N_YiWztV_qbaLQvA@mail.gmail.com/
|
|
Let's Encrypt is working well for us and having fewer domains
reduces subjectAltName bloat to speed up connection
establishment
HTTP will remain working indefinitely since some old systems
do not have modern TLS stacks.
|
|
In case Revactor starts being maintained again...
(heck, it was probably the reason I started Rainbows! in the first
place...)
Our ReverseProxy stuff was never complete nor marketed;
and probably not worth keeping around at all.
|
|
Oops, blind substitution :x
|
|
Redundant \z statements are ugly and wastes 4 bytes on x86-64
according to ObjectSpace.memsize_of
|
|
In the unlikely case somebody runs revactor, they won't need to
load the extra fcntl.so library into their process anymore.
In retrospect, we could've alway used IO#close_on_exec= since
it appeared in 1.9.1 and (IIRC) revactor always required 1.9.1+
|
|
unicorn 5 will only support Ruby 1.9.3 and later, so remove
some checks for Hash#compare_by_identity and IO.copy_stream
which we know exist in Ruby 1.9.
Favor &:sym proc dispatch to avoid unnecessary captures and
bytecode size increases, too.
Finally, ensure we fail fast by converting some literal
hashes to use non-arrow syntax for symbolic keys.
|
|
Less code in cold paths can improve speed for hot paths.
Single-byte strings for String#split is optimized in mainline Ruby,
so it's not actually a performance loss for sendfile_range in
response.rb
Regexps are at least 400 bytes each, so prefer non-Regexps
if possible, especially for cold sites where performance does
not matter.
|
|
Even with frozen string literals enabled in Ruby 2.3.0dev,
dstrings still create garbage as the optimizer is
not yet smart enough to optimize it despite the limited
choice of internals being known.
Maybe in the future Ruby will be smart enough, but not yet...
|
|
The timeout (mis)feature in unicorn uses the monotonic clock
if available. We must follow suit to avoid having our timeout
functionality completely broken.
|
|
unicorn 5.0.0 assumes Rack hijack is always available if
the application tries to use it, so the wrapper method
is removed.
|
|
We'll need this for unicorn 5, as they dropped this publically
accessible attribute while retaining the ivar. Eventually we
may not have to check this attribute at all, instead detecting
parent death via worker pipe.
|
|
unicorn lost the hijack_setup method in version 5,
so we must recreate it ourselves.
|
|
Unicorn 5 removes some constants we were using, and constant
lookups + inline caching are waste of time anyways on newer
Rubies with the opt_str_freeze bytecode instruction.
This may reduce performance for folks on older Rubies (probably
not noticeable); but improves performance for folks on newer
Rubies.
|
|
Applications may want to alter the message associated with HTTP
status codes in Rack::Utils::HTTP_STATUS_CODES. Avoid memoizing
status lines ahead-of-time
Note: this introduces a minor performance regression, but ought to
be unnoticeable unless you're running "Hello world"-type apps.
|
|
Whatever compatibility reasons which existed in 2009 likely do not exist
now. Other servers (e.g. thin, puma) seem to work alright without it,
so there's no reason to waste precious bytes.
|
|
unicorn 5 dropped support for this, essentially allowing unlimited
persistent connections if we used the parser as-is.
Since most of our concurrency models cannot handle infinite
persistent connections without being vulnerable to DoS,
we must support keepalive_requests like nginx does.
|
|
WriterThreadPool, WriterThreadSpawn, Base, and potentially
other rarely-used concurrency options experienced slow shutdowns
due to the destruction of a listener socket failing to wake up
a thread in IO.select.
Send ourselves a signal to interrupt the IO.select call in
the main thread to force the wakeup.
|
|
This will allow us use the sendfile syscall under Linux on
Ruby which favor #read/#readpartial methods for non-IO objects.
This also allows us to revert changes made in
commit db790ff3531acdfa23ab290998bba29360a6782b
("sync_close: This fix breakage from Ruby-trunk r50118")
|
|
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.
|