* [ANN] yahns 1.10.0 -_- sleepy app server for Ruby
[not found] <20151101-yahns-1.10.0-rele@sed>
@ 2015-11-01 9:25 6% ` Eric Wong
0 siblings, 0 replies; 4+ results
From: Eric Wong @ 2015-11-01 9:25 UTC (permalink / raw)
To: ruby-talk, yahns-public
A Free Software, multi-threaded, non-blocking network application server
designed for low _idle_ power consumption. It is primarily optimized
for applications with occasional users which see little or no traffic.
yahns currently hosts Rack/HTTP applications, but may eventually support
other application types. Unlike some existing servers, yahns is
extremely sensitive to fatal bugs in the applications it hosts.
minor updates
This release improves socket inheritance support. TCP socket
options are now applied to inherited sockets. We also emulate
the sd_listen_fds function to allow inheriting sockets from
systemd.
HTTP status strings are now generated dynamically, allowing
applications to modify Rack::Utils::HTTP_STATUS_CODES to
apply changes in the Rack response. Unfortunately, this leads
to minor (likely unnoticeable) performance regressions.
However, our code is not optimized for Ruby 2.2+, so users on
the latest released Ruby will benefit from reduced inline cache
and constant lookups as we reduced our constant footprint.
Expect further minor performance regressions if you are running
Ruby 2.2 and earlier.
For Ruby 2.2 users, overall performance should be largely
unchanged from 1.7.0 to 1.8.0
shortlog of changes since 1.7.0:
* use opt_str_freeze for Hash#delete
* test/helper: warn atomically
* generate response status strings dynamically
* reduce constants and optimize for Ruby 2.2+
* http_response: reduce bytecode size
* apply TCP socket options on inherited sockets
* test/test_rack_hijack.rb: try to increase test reliability
* emulate sd_listen_fds for systemd support
* test/test_rack_hijack: ensure proper ordering of log messages
Since I'm also the BDFL of unicorn, questions comparing the two may be
inevitable. In short, they are complete opposites in implementation.
More will be posted in the following thread, but for now there's an
incomplete overview:
http://yhbt.net/yahns-public/20151101092053.GA5328@dcvr.yhbt.net/t/
Please note the disclaimer:
yahns is extremely sensitive to fatal bugs in the apps it hosts. There
is no (and never will be) any built-in "watchdog"-type feature to kill
stuck processes/threads. Each yahns process may be handling thousands
of clients; unexpectedly killing the process will abort _all_ of those
connections. Lives may be lost!
yahns hackers are not responsible for your application/library bugs.
Use an application server which is tolerant of buggy applications
if you cannot be bothered to fix all your fatal bugs.
* git clone git://yhbt.net/yahns
* http://yahns.yhbt.net/README
* http://yahns.yhbt.net/NEWS.atom.xml
* we only accept plain-text email yahns-public@yhbt.net
* and archive all the mail we receive: http://yhbt.net/yahns-public/
* nntp://news.public-inbox.org/inbox.comp.lang.ruby.yahns
--
EW
^ permalink raw reply [relevance 6%]
* [ANN] yahns 1.9.0 -_- sleepy app server for Ruby
@ 2015-07-21 20:39 6% Eric Wong
0 siblings, 0 replies; 4+ results
From: Eric Wong @ 2015-07-21 20:39 UTC (permalink / raw)
To: ruby-talk, yahns-public
A Free Software, multi-threaded, non-blocking network application server
designed for low _idle_ power consumption. It is primarily optimized
for applications with occasional users which see little or no traffic.
yahns currently hosts Rack/HTTP applications, but may eventually support
other application types. Unlike some existing servers, yahns is
extremely sensitive to fatal bugs in the applications it hosts.
minor updates
This release improves socket inheritance support. TCP socket
options are now applied to inherited sockets. We also emulate
the sd_listen_fds function to allow inheriting sockets from
systemd.
HTTP status strings are now generated dynamically, allowing
applications to modify Rack::Utils::HTTP_STATUS_CODES to
apply changes in the Rack response. Unfortunately, this leads
to minor (likely unnoticeable) performance regressions.
However, our code is not optimized for Ruby 2.2+, so users on
the latest released Ruby will benefit from reduced inline cache
and constant lookups as we reduced our constant footprint.
Expect further minor performance regressions if you are running
Ruby 2.2 and earlier.
For Ruby 2.2 users, overall performance should be largely
unchanged from 1.7.0 to 1.8.0
shortlog of changes since 1.7.0:
* use opt_str_freeze for Hash#delete
* test/helper: warn atomically
* generate response status strings dynamically
* reduce constants and optimize for Ruby 2.2+
* http_response: reduce bytecode size
* apply TCP socket options on inherited sockets
* test/test_rack_hijack.rb: try to increase test reliability
* emulate sd_listen_fds for systemd support
* test/test_rack_hijack: ensure proper ordering of log messages
Please note the disclaimer:
yahns is extremely sensitive to fatal bugs in the apps it hosts. There
is no (and never will be) any built-in "watchdog"-type feature to kill
stuck processes/threads. Each yahns process may be handling thousands
of clients; unexpectedly killing the process will abort _all_ of those
connections. Lives may be lost!
yahns hackers are not responsible for your application/library bugs.
Use an application server which is tolerant of buggy applications
if you cannot be bothered to fix all your fatal bugs.
* git clone git://yhbt.net/yahns
* http://yahns.yhbt.net/README
* http://yahns.yhbt.net/NEWS.atom.xml
* we only accept plain-text email yahns-public@yhbt.net
* and archive all the mail we receive: http://yhbt.net/yahns-public/
--
EW
^ permalink raw reply [relevance 6%]
* [PATCH 2/3] reduce constants and optimize for Ruby 2.2+
2015-06-30 3:01 7% [PATCH 0/3] favor newer Rubies for performance Eric Wong
@ 2015-06-30 3:01 6% ` Eric Wong
0 siblings, 0 replies; 4+ results
From: Eric Wong @ 2015-06-30 3:01 UTC (permalink / raw)
To: yahns-public; +Cc: e
Ruby (MRI) 2.1 optimizes allocations away on String#freeze with
literal strings.
Furthermore, Ruby 2.2 optimizes away literal string allocations
when they are used as arguments to Hash#[] and Hash#[]=
Thus we can avoid expensive constant lookups and cache overhead
by taking advantage of advancements in Ruby.
Since Ruby 2.2 has been out for 7 months, now; it ought to be safe
to introduce minor performance regressions for folks using older
Rubies (1.9.3+ remains supported) to benefit folks on the latest
Ruby.
---
lib/yahns/http_client.rb | 16 +++++-----------
lib/yahns/http_response.rb | 15 +++++----------
lib/yahns/max_body.rb | 12 ++++--------
lib/yahns/proxy_http_response.rb | 5 +++--
4 files changed, 17 insertions(+), 31 deletions(-)
diff --git a/lib/yahns/http_client.rb b/lib/yahns/http_client.rb
index 0c656e8..9a37811 100644
--- a/lib/yahns/http_client.rb
+++ b/lib/yahns/http_client.rb
@@ -11,12 +11,6 @@ class Yahns::HttpClient < Kgio::Socket # :nodoc:
include Yahns::HttpResponse
QEV_FLAGS = Yahns::Queue::QEV_RD # used by acceptor
- # A frozen format for this is about 15% faster (note from Mongrel)
- REMOTE_ADDR = 'REMOTE_ADDR'.freeze
- RACK_INPUT = 'rack.input'.freeze
- RACK_HIJACK = 'rack.hijack'.freeze
- RACK_HIJACK_IO = "rack.hijack_io".freeze
-
# called from acceptor thread
def yahns_init
@hs = Unicorn::HttpRequest.new
@@ -206,9 +200,9 @@ class Yahns::HttpClient < Kgio::Socket # :nodoc:
# input is nil if we needed to wait for writability with
# check_client_connection
if input
- env[REMOTE_ADDR] = @kgio_addr
- env[RACK_HIJACK] = self
- env[RACK_INPUT] = input
+ env['REMOTE_ADDR'] = @kgio_addr
+ env['rack.hijack'] = self
+ env['rack.input'] = input
if k.check_client_connection && @hs.headers?
rv = do_ccc and return rv
@@ -262,7 +256,7 @@ class Yahns::HttpClient < Kgio::Socket # :nodoc:
# this is the env["rack.hijack"] callback exposed to the Rack app
def call
hijack_cleanup
- @hs.env[RACK_HIJACK_IO] = self
+ @hs.env['rack.hijack_io'] = self
end
def response_hijacked(fn)
@@ -300,7 +294,7 @@ class Yahns::HttpClient < Kgio::Socket # :nodoc:
end
def app_hijacked?(env, body)
- return false unless env.include?(RACK_HIJACK_IO)
+ return false unless env.include?('rack.hijack_io'.freeze)
body.close if body.respond_to?(:close)
true
end
diff --git a/lib/yahns/http_response.rb b/lib/yahns/http_response.rb
index b70491d..f50c9a1 100644
--- a/lib/yahns/http_response.rb
+++ b/lib/yahns/http_response.rb
@@ -23,13 +23,7 @@ module Yahns::HttpResponse # :nodoc:
end
# avoid GC overhead for frequently used-strings:
- CONN_KA = "Connection: keep-alive\r\n\r\n"
- CONN_CLOSE = "Connection: close\r\n\r\n"
- Z = ""
CCC_RESPONSE_START = [ 'HTTP', '/1.1 ' ]
- RESPONSE_START = CCC_RESPONSE_START.join
- REQUEST_METHOD = "REQUEST_METHOD"
- HEAD = "HEAD"
# no point in using one without the other, these have been in Linux
# for ages
@@ -46,7 +40,7 @@ module Yahns::HttpResponse # :nodoc:
end
def response_start
- @hs.response_start_sent ? Z : RESPONSE_START
+ @hs.response_start_sent ? ''.freeze : 'HTTP/1.1 '.freeze
end
def response_wait_write(rv)
@@ -115,7 +109,7 @@ module Yahns::HttpResponse # :nodoc:
end
def kv_str(key, value)
- if value =~ /\n/
+ if value.include?("\n".freeze)
# avoiding blank, key-only cookies with /\n+/
value.split(/\n+/).map! { |v| "#{key}: #{v}\r\n" }.join
else
@@ -124,7 +118,7 @@ module Yahns::HttpResponse # :nodoc:
end
def have_more?(value)
- value.to_i > 0 && @hs.env[REQUEST_METHOD] != HEAD
+ value.to_i > 0 && @hs.env['REQUEST_METHOD'] != 'HEAD'.freeze
end
# writes the rack_response to socket as an HTTP response
@@ -163,7 +157,8 @@ module Yahns::HttpResponse # :nodoc:
buf << kv_str(key, value)
end
end
- buf << (alive ? CONN_KA : CONN_CLOSE)
+ buf << (alive ? "Connection: keep-alive\r\n\r\n".freeze
+ : "Connection: close\r\n\r\n".freeze)
case rv = kgio_syssend(buf, flags)
when nil # all done, likely
break
diff --git a/lib/yahns/max_body.rb b/lib/yahns/max_body.rb
index fadbddc..e52a10f 100644
--- a/lib/yahns/max_body.rb
+++ b/lib/yahns/max_body.rb
@@ -28,17 +28,13 @@ class Yahns::MaxBody # :nodoc:
@limit = limit
end
- RACK_INPUT = "rack.input".freeze # :nodoc:
- CONTENT_LENGTH = "CONTENT_LENGTH" # :nodoc:
- HTTP_TRANSFER_ENCODING = "HTTP_TRANSFER_ENCODING" # :nodoc:
-
# our main Rack middleware endpoint
def call(env) # :nodoc:
catch(:yahns_EFBIG) do
- len = env[CONTENT_LENGTH]
+ len = env['CONTENT_LENGTH']
if len && len.to_i > @limit
return err
- elsif /\Achunked\z/i =~ env[HTTP_TRANSFER_ENCODING]
+ elsif /\Achunked\z/i =~ env['HTTP_TRANSFER_ENCODING']
limit_input!(env)
end
@app.call(env)
@@ -51,9 +47,9 @@ class Yahns::MaxBody # :nodoc:
end
def limit_input!(env) # :nodoc:
- input = env[RACK_INPUT]
+ input = env['rack.input']
klass = input.respond_to?(:rewind) ? RewindableWrapper : Wrapper
- env[RACK_INPUT] = klass.new(input, @limit)
+ env['rack.input'] = klass.new(input, @limit)
end
end
require_relative 'max_body/wrapper'
diff --git a/lib/yahns/proxy_http_response.rb b/lib/yahns/proxy_http_response.rb
index 61989c2..50c841d 100644
--- a/lib/yahns/proxy_http_response.rb
+++ b/lib/yahns/proxy_http_response.rb
@@ -64,7 +64,7 @@ module Yahns::HttpResponse # :nodoc:
msg = Rack::Utils::HTTP_STATUS_CODES[code]
env = @hs.env
have_body = !Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include?(code) &&
- env[REQUEST_METHOD] != HEAD
+ env['REQUEST_METHOD'] != 'HEAD'.freeze
flags = MSG_DONTWAIT
alive = @hs.next? && self.class.persistent_connections
response_headers = env['yahns.proxy_pass.response_headers']
@@ -91,7 +91,8 @@ module Yahns::HttpResponse # :nodoc:
# For now, do not add a Date: header, assume upstream already did it
# but do not care if they did not
- res << (alive ? CONN_KA : CONN_CLOSE)
+ res << (alive ? "Connection: keep-alive\r\n\r\n"
+ : "Connection: close\r\n\r\n")
# send the headers
case rv = kgio_syssend(res, flags)
--
EW
^ permalink raw reply related [relevance 6%]
* [PATCH 0/3] favor newer Rubies for performance
@ 2015-06-30 3:01 7% Eric Wong
2015-06-30 3:01 6% ` [PATCH 2/3] reduce constants and optimize for Ruby 2.2+ Eric Wong
0 siblings, 1 reply; 4+ results
From: Eric Wong @ 2015-06-30 3:01 UTC (permalink / raw)
To: yahns-public; +Cc: e
* [PATCH 1/3] generate response status strings dynamically
This unfortunately introduces a minor performance regression.
However, it is unlikely to be noticeable in real-world apps.
* [PATCH 2/3] reduce constants and optimize for Ruby 2.2+
This appears to recover the performance lost in 1/3 when doing
informal benchmarks on a private app (persistent connections
enabled).
* [PATCH 3/3] http_response: reduce bytecode size
This generates less bytecode when checking with
RubyVM::InstructionSequence.compile
lib/yahns/http_client.rb | 16 +++++-----------
lib/yahns/http_response.rb | 35 ++++++++++++++++-------------------
lib/yahns/max_body.rb | 12 ++++--------
lib/yahns/proxy_http_response.rb | 16 +++++++++-------
4 files changed, 34 insertions(+), 45 deletions(-)
^ permalink raw reply [relevance 7%]
Results 1-4 of 4 | reverse | options above
-- pct% links below jump to the message on this page, permalinks otherwise --
2015-06-30 3:01 7% [PATCH 0/3] favor newer Rubies for performance Eric Wong
2015-06-30 3:01 6% ` [PATCH 2/3] reduce constants and optimize for Ruby 2.2+ Eric Wong
2015-07-21 20:39 6% [ANN] yahns 1.9.0 -_- sleepy app server for Ruby Eric Wong
[not found] <20151101-yahns-1.10.0-rele@sed>
2015-11-01 9:25 6% ` [ANN] yahns 1.10.0 " Eric Wong
Code repositories for project(s) associated with this public inbox
https://yhbt.net/yahns.git/
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).