rainbows 4.7.0 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 696829a7735d042f66084bbbf36e17658edd8a78
-  data.tar.gz: 8ca5eb73b0c23373c9ac41a23866506de6b6b649
+  metadata.gz: b971749285f91c7a3a1b8c6340e8e349ee3d0468
+  data.tar.gz: a8e7bf3756f75ceafc3c4bd9333f6885079055ae
 SHA512:
-  metadata.gz: cb200f3630bf46e0a3be33a6dcd132f3f555eb72cdfd65145781d2488ccbfa3fc8f7b35db3c3d5e9ab4aa8707ddd373b80efe5129b4a13e54df2483939bd4ad4
-  data.tar.gz: b08b512c0fc0f71f78efa8000cb150cbc7a5ece957b1f1a51bc7dda11e73f488d4f865752932b94b1b07fb66b93d08093fc8780620347a516b389af1964d46ad
+  metadata.gz: f5e3e727d58a0916e748c1029aeb8433623406a4e8816e24db77452bde792974f066558322a7d38b1360aaa63f5451dbf6eb4f5ef7b9ef5667e45ccd2619ff92
+  data.tar.gz: 7ff15b6b42d53fc040a4bd1a46382dbfbcd6ccefacf12fc266bed97f10e6b49d2f0947f64db9db8b54103710273f5dfbd576b0a505afd8ad3430e8e82eb28f7f

data/.gitattributes

@@ -0,0 +1,5 @@
+*.gemspec diff=ruby
+*.rb diff=ruby
+*.ru diff=ruby
+Rakefile diff=ruby
+bin/* diff=ruby

data/GIT-VERSION-GEN

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
-DEF_VER = "v4.7.0"
+DEF_VER = "v5.0.0"
 CONSTANT = "Rainbows::Const::RAINBOWS_VERSION"
 RVF = "lib/rainbows/version.rb"
 GVF = "GIT-VERSION-FILE"

data/README

@@ -6,18 +6,13 @@ request/response times and/or slow clients.
 
 If you're on GNU/Linux and overwhelmed by options in \Rainbows!,
 consider {yahns}[http://yahns.yhbt.net/] as it has fewer options
-and more energy-efficient during non-peak traffic.
+and more energy-efficient during non-peak traffic and may also
+be configured as a single worker process.
 
 For Rack applications not heavily bound by slow external network
 dependencies, consider unicorn instead as it simpler and easier to
 debug.
 
-If you're on a small system, or write extremely tight and reliable code
-and don't want multiple worker processes, check out
-{Zbatery}[http://zbatery.bogomip.org/], too. Zbatery can use all the
-crazy network concurrency options of \Rainbows! in a single worker
-process.
-
 == \Rainbows! is about Diversity
 
 We aim to support as many concurrency models as we can because they all
@@ -169,9 +164,10 @@ and we'll try our best to fix it.
 All feedback (bug reports, user/development discussion, patches, pull
 requests) go to the mailing list.  Patches must be sent inline
 (git format-patch -M + git send-email).  No subscription is necessary
-to post on the mailing list.  No top posting.  Address replies +To:+
-the mailing list.
+to post on the mailing list.  No top posting.
 
 * email: mailto:rainbows-public@bogomips.org
 * subscribe: mailto:rainbows-public+subscribe@bogomips.org
 * archives: http://bogomips.org/rainbows-public/
+  nntp://news.public-inbox.org/inbox.comp.lang.ruby.rainbows
+  nntp://news.gmane.org/gmane.comp.lang.ruby.rainbows.general

data/bin/rainbows

@@ -117,9 +117,9 @@
 if $DEBUG
   require 'pp'
   pp({
-    :unicorn_options => options,
-    :app => app,
-    :daemonize => rackup_opts[:daemonize],
+    unicorn_options: options,
+    app: app,
+    daemonize: rackup_opts[:daemonize],
   })
 end
 

data/lib/rainbows.rb

@@ -11,8 +11,7 @@ module Rainbows
 
   # map of numeric file descriptors to IO objects to avoid using IO.new
   # and potentially causing race conditions when using /dev/fd/
-  FD_MAP = {}
-  FD_MAP.compare_by_identity if FD_MAP.respond_to?(:compare_by_identity)
+  FD_MAP = {}.compare_by_identity
 
   require 'rainbows/const'
   require 'rainbows/http_parser'
@@ -75,8 +74,8 @@ def self.at_quit(&block)
   end
 
   def self.tick
-    @worker.tick = Time.now.to_i
-    exit!(2) if @expire && Time.now >= @expire
+    @worker.tick = now.to_i
+    exit!(2) if @expire && now >= @expire
     @alive && @server.master_pid == Process.ppid or quit!
   end
 
@@ -88,11 +87,11 @@ def self.quit!
     unless @expire
       @alive = false
       Rainbows::HttpParser.quit
-      @expire = Time.now + (@server.timeout * 2.0)
+      @expire = now + (@server.timeout * 2.0)
       tmp = @readers.dup
       @readers.clear
       tmp.each { |s| s.close rescue nil }.clear
-      @at_quit.each { |task| task.call }
+      @at_quit.each(&:call)
 
       # XXX hack to break out of IO.select in worker_loop for some models
       Process.kill(:QUIT, $$)
@@ -100,6 +99,19 @@ def self.quit!
     false
   end
 
+  # try to use the monotonic clock in Ruby >= 2.1, it is immune to clock
+  # offset adjustments and generates less garbage (Float vs Time object)
+  begin
+    Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    def self.now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  rescue NameError, NoMethodError
+    def self.now # Ruby <= 2.0
+      Time.now.to_f
+    end
+  end
+
   autoload :Base, "rainbows/base"
   autoload :WriterThreadPool, "rainbows/writer_thread_pool"
   autoload :WriterThreadSpawn, "rainbows/writer_thread_spawn"

data/lib/rainbows/configurator.rb

@@ -21,14 +21,14 @@
 #   stdout_path "/path/to/output.log"
 module Rainbows::Configurator
   Unicorn::Configurator::DEFAULTS.merge!({
-    :use => Rainbows::Base,
-    :worker_connections => 50,
-    :keepalive_timeout => 5,
-    :keepalive_requests => 100,
-    :client_max_body_size => 1024 * 1024,
-    :client_header_buffer_size => 1024,
-    :client_max_header_size => 112 * 1024,
-    :copy_stream => IO.respond_to?(:copy_stream) ? IO : false,
+    use: Rainbows::Base,
+    worker_connections: 50,
+    keepalive_timeout: 5,
+    keepalive_requests: 100,
+    client_max_body_size: 1024 * 1024,
+    client_header_buffer_size: 1024,
+    client_max_header_size: 112 * 1024,
+    copy_stream: IO,
   })
 
   # Configures \Rainbows! with a given concurrency model to +use+ and

data/lib/rainbows/const.rb

@@ -13,7 +13,4 @@ module Rainbows::Const
     # if they're the response body.  Unset by default.
     # "rainbows.autochunk" => false,
   })
-
-  RACK_INPUT = Unicorn::HttpRequest::RACK_INPUT
-  REMOTE_ADDR = Unicorn::HttpRequest::REMOTE_ADDR
 end

data/lib/rainbows/coolio.rb

@@ -27,15 +27,10 @@
 module Rainbows::Coolio
   # :stopdoc:
   # keep-alive timeout scoreboard
-  KATO = {}
+  KATO = {}.compare_by_identity
 
   # all connected clients
-  CONN = {}
-
-  if {}.respond_to?(:compare_by_identity)
-    CONN.compare_by_identity
-    KATO.compare_by_identity
-  end
+  CONN = {}.compare_by_identity
 
   autoload :Client, 'rainbows/coolio/client'
   autoload :Master, 'rainbows/coolio/master'

data/lib/rainbows/coolio/client.rb

@@ -122,10 +122,10 @@ def ev_write_response(status, headers, body, alive)
   def app_call input
     KATO.delete(self)
     disable if enabled?
-    @env[RACK_INPUT] = input
-    @env[REMOTE_ADDR] = @_io.kgio_addr
-    @env[ASYNC_CALLBACK] = method(:write_async_response)
-    @hp.hijack_setup(@env, @_io)
+    @env['rack.input'] = input
+    @env['REMOTE_ADDR'] = @_io.kgio_addr
+    @env['async.callback'] = method(:write_async_response)
+    @hp.hijack_setup(@_io)
     status, headers, body = catch(:async) {
       APP.call(@env.merge!(RACK_DEFAULTS))
     }
@@ -154,10 +154,10 @@ def on_write_complete
         # buf == :wait_readable
         unless enabled?
           enable
-          KATO[self] = Time.now
+          KATO[self] = Rainbows.now
         end
       else
-        on_read(Z)
+        on_read(''.freeze)
       end
     end
     rescue => e

data/lib/rainbows/coolio/heartbeat.rb

@@ -9,11 +9,11 @@ class Rainbows::Coolio::Heartbeat < Coolio::TimerWatcher
   KATO = Rainbows::Coolio::KATO
   CONN = Rainbows::Coolio::CONN
   Rainbows.config!(self, :keepalive_timeout)
-  Rainbows.at_quit { KATO.each_key { |client| client.timeout? }.clear }
+  Rainbows.at_quit { KATO.each_key(&:timeout?).clear }
 
   def on_timer
     if (ot = KEEPALIVE_TIMEOUT) >= 0
-      ot = Time.now - ot
+      ot = Rainbows.now - ot
       KATO.delete_if { |client, time| time < ot and client.timeout? }
     end
     exit if (! Rainbows.tick && CONN.size <= 0)

data/lib/rainbows/coolio/thread_client.rb

@@ -8,7 +8,7 @@ class Rainbows::Coolio::ThreadClient < Rainbows::Coolio::Client
   def app_call input
     KATO.delete(self)
     disable if enabled?
-    @env[RACK_INPUT] = input
+    @env['rack.input'] = input
     app_dispatch # must be implemented by subclass
   end
 
@@ -25,8 +25,8 @@ def response_write(response)
   # here because that could cause a deadlock and we'd leak FDs
   def app_response
     begin
-      @env[REMOTE_ADDR] = @_io.kgio_addr
-      @hp.hijack_setup(@env, @_io)
+      @env['REMOTE_ADDR'] = @_io.kgio_addr
+      @hp.hijack_setup(@_io)
       APP.call(@env.merge!(RACK_DEFAULTS))
     rescue => e
       Rainbows::Error.app(e) # we guarantee this does not raise

data/lib/rainbows/dev_fd_response.rb

@@ -11,12 +11,6 @@ class Rainbows::DevFdResponse < Struct.new(:app)
 
   # :stopdoc:
   FD_MAP = Rainbows::FD_MAP
-  Content_Length = "Content-Length".freeze
-  Transfer_Encoding = "Transfer-Encoding".freeze
-  Rainbows_autochunk = "rainbows.autochunk".freeze
-  Rainbows_model = "rainbows.model"
-  HTTP_VERSION = "HTTP_VERSION"
-  Chunked = "chunked"
   include Rack::Utils
 
   # Rack middleware entry point, we'll just pass through responses
@@ -40,23 +34,23 @@ def call(env)
     fileno = io.fileno
     FD_MAP[fileno] = io
     if st.file?
-      headers[Content_Length] ||= st.size.to_s
-      headers.delete(Transfer_Encoding)
+      headers['Content-Length'.freeze] ||= st.size.to_s
+      headers.delete('Transfer-Encoding'.freeze)
     elsif st.pipe? || st.socket? # epoll-able things
-      unless headers.include?(Content_Length)
-        if env[Rainbows_autochunk]
-          case env[HTTP_VERSION]
+      unless headers.include?('Content-Length'.freeze)
+        if env['rainbows.autochunk']
+          case env['HTTP_VERSION']
           when "HTTP/1.0", nil
           else
-            headers[Transfer_Encoding] = Chunked
+            headers['Transfer-Encoding'.freeze] = 'chunked'
           end
         else
-          env[Rainbows_autochunk] = false
+          env['rainbows.autochunk'] = false
         end
       end
 
       # we need to make sure our pipe output is Fiber-compatible
-      case env[Rainbows_model]
+      case env['rainbows.model']
       when :FiberSpawn, :FiberPool, :RevFiberSpawn, :CoolioFiberSpawn
         io.respond_to?(:kgio_wait_readable) or
           io = Rainbows::Fiber::IO.new(io)

data/lib/rainbows/epoll/client.rb

@@ -9,15 +9,14 @@ module Rainbows::Epoll::Client
   IN = SleepyPenguin::Epoll::IN | SleepyPenguin::Epoll::ONESHOT
   OUT = SleepyPenguin::Epoll::OUT | SleepyPenguin::Epoll::ONESHOT
   EPINOUT = IN | OUT
-  KATO = {}
-  KATO.compare_by_identity if KATO.respond_to?(:compare_by_identity)
-  Rainbows.at_quit { KATO.each_key { |k| k.timeout! }.clear }
+  KATO = {}.compare_by_identity
+  Rainbows.at_quit { KATO.each_key(&:timeout!).clear }
   Rainbows.config!(self, :keepalive_timeout)
   EP = Rainbows::EP
-  @@last_expire = Time.now
+  @@last_expire = Rainbows.now
 
   def self.expire
-    return if ((now = Time.now) - @@last_expire) < 1.0
+    return if ((now = Rainbows.now) - @@last_expire) < 1.0
     if (ot = KEEPALIVE_TIMEOUT) >= 0
       ot = now - ot
       KATO.delete_if { |client, time| time < ot and client.timeout! }
@@ -63,9 +62,9 @@ def on_readable
   end
 
   def app_call input # called by on_read()
-    @env[RACK_INPUT] = input
-    @env[REMOTE_ADDR] = kgio_addr
-    @hp.hijack_setup(@env, self)
+    @env['rack.input'] = input
+    @env['REMOTE_ADDR'] = kgio_addr
+    @hp.hijack_setup(self)
     status, headers, body = APP.call(@env.merge!(RACK_DEFAULTS))
     return hijacked if @hp.hijacked?
     ev_write_response(status, headers, body, @hp.next?)
@@ -93,7 +92,7 @@ def stream_response_body(body, io, chunk)
                     Rainbows::Epoll::ResponsePipe).new(io, self, body)
     return @wr_queue << pipe if @wr_queue[0]
     stream_pipe(pipe) or return
-    @wr_queue[0] or @wr_queue << Z
+    @wr_queue[0] or @wr_queue << ''.freeze
   end
 
   def ev_write_response(status, headers, body, alive)
@@ -120,7 +119,7 @@ def next_request
       want_more
     else
       # pipelined request (already in buffer)
-      on_read(Z)
+      on_read(''.freeze)
       return if @wr_queue[0] || closed?
       return hijacked if @hp.hijacked?
       close if :close == @state

data/lib/rainbows/error.rb

@@ -28,11 +28,11 @@ def self.response(e)
          Errno::EBADF, Errno::ENOTCONN, Errno::ETIMEDOUT, Errno::EHOSTUNREACH
       # swallow error if client shuts down one end or disconnects
     when Unicorn::HttpParserError
-      Rainbows::Const::ERROR_400_RESPONSE # try to tell the client they're bad
+      "HTTP/1.1 400 Bad Request\r\n\r\n" # try to tell the client they're bad
     when IOError # HttpParserError is an IOError
     else
       app(e)
-      Rainbows::Const::ERROR_500_RESPONSE
+      "HTTP/1.1 500 Internal Server Error\r\n\r\n"
     end
   end
 end

data/lib/rainbows/ev_core.rb

@@ -8,13 +8,9 @@ module Rainbows::EvCore
   HttpParser = Rainbows::HttpParser
   autoload :CapInput, 'rainbows/ev_core/cap_input'
   RBUF = ""
-  Z = "".freeze
   Rainbows.config!(self, :client_header_buffer_size)
-  HTTP_VERSION = "HTTP_VERSION"
 
   # Apps may return this Rack response: AsyncResponse = [ -1, {}, [] ]
-  ASYNC_CALLBACK = "async.callback".freeze
-  ASYNC_CLOSE = "async.close".freeze
 
   def write_async_response(response)
     status, headers, body = response
@@ -23,8 +19,8 @@ def write_async_response(response)
       # "Transfer-Encoding: chunked", and the async.callback stuff
       # isn't Rack::Lint-compatible, so we have to enforce it here.
       headers = Rack::Utils::HeaderHash.new(headers) unless Hash === headers
-      alive = headers.include?(Content_Length) ||
-              !!(%r{\Achunked\z}i =~ headers[Transfer_Encoding])
+      alive = headers.include?('Content-Length'.freeze) ||
+              !!(%r{\Achunked\z}i =~ headers['Transfer-Encoding'.freeze])
     end
     @deferred = nil
     ev_write_response(status, headers, body, alive)
@@ -55,12 +51,12 @@ def handle_error(e)
   # returns nil if request was hijacked in response stage
   def stream_response_headers(status, headers, alive, body)
     headers = Rack::Utils::HeaderHash.new(headers) unless Hash === headers
-    if headers.include?(Content_Length)
+    if headers.include?('Content-Length'.freeze)
       write_headers(status, headers, alive, body) or return
       return false
     end
 
-    case @env[HTTP_VERSION]
+    case @env['HTTP_VERSION']
     when "HTTP/1.0" # disable HTTP/1.0 keepalive to stream
       write_headers(status, headers, false, body) or return
       @hp.clear
@@ -68,7 +64,7 @@ def stream_response_headers(status, headers, alive, body)
     when nil # "HTTP/0.9"
       false
     else
-      rv = !!(headers[Transfer_Encoding] =~ %r{\Achunked\z}i)
+      rv = !!(headers['Transfer-Encoding'] =~ %r{\Achunked\z}i)
       rv = false unless @env["rainbows.autochunk"]
       write_headers(status, headers, alive, body) or return
       rv
@@ -78,14 +74,14 @@ def stream_response_headers(status, headers, alive, body)
   def prepare_request_body
     # since we don't do streaming input, we have no choice but
     # to take over 100-continue handling from the Rack application
-    if @env[HTTP_EXPECT] =~ /\A100-continue\z/i
-      write(EXPECT_100_RESPONSE)
-      @env.delete(HTTP_EXPECT)
+    if @env['HTTP_EXPECT'] =~ /\A100-continue\z/i
+      write("HTTP/1.1 100 Continue\r\n\r\n".freeze)
+      @env.delete('HTTP_EXPECT'.freeze)
     end
     @input = mkinput
     @hp.filter_body(@buf2 = "", @buf)
     @input << @buf2
-    on_read(Z)
+    on_read(''.freeze)
   end
 
   # TeeInput doesn't map too well to this right now...
@@ -111,7 +107,7 @@ def on_read(data)
       elsif data.size > 0
         @hp.filter_body(@buf2, @buf << data)
         @input << @buf2
-        on_read(Z)
+        on_read(''.freeze)
       else
         want_more
       end
@@ -127,10 +123,8 @@ def on_read(data)
       handle_error(e)
   end
 
-  ERROR_413_RESPONSE = "HTTP/1.1 413 Request Entity Too Large\r\n\r\n"
-
   def err_413(msg)
-    write(ERROR_413_RESPONSE)
+    write("HTTP/1.1 413 Request Entity Too Large\r\n\r\n".freeze)
     quit
     # zip back up the stack
     raise IOError, msg, []

data/lib/rainbows/event_machine/client.rb

@@ -23,7 +23,7 @@ def receive_data(data)
       end
       EM.next_tick { receive_data(nil) } unless @buf.empty?
     else
-      on_read(data || Z) if (@buf.size > 0) || data
+      on_read(data || ''.freeze) if (@buf.size > 0) || data
     end
   end
 
@@ -34,11 +34,11 @@ def quit
 
   def app_call input
     set_comm_inactivity_timeout 0
-    @env[RACK_INPUT] = input
-    @env[REMOTE_ADDR] = @_io.kgio_addr
-    @env[ASYNC_CALLBACK] = method(:write_async_response)
-    @env[ASYNC_CLOSE] = EM::DefaultDeferrable.new
-    @hp.hijack_setup(@env, @_io)
+    @env['rack.input'] = input
+    @env['REMOTE_ADDR'] = @_io.kgio_addr
+    @env['async.callback'] = method(:write_async_response)
+    @env['async.close'] = EM::DefaultDeferrable.new
+    @hp.hijack_setup(@_io)
     status, headers, body = catch(:async) {
       APP.call(@env.merge!(RACK_DEFAULTS))
     }
@@ -117,7 +117,7 @@ def next!
 
   def unbind
     return if @hp.hijacked?
-    async_close = @env[ASYNC_CLOSE] and async_close.succeed
+    async_close = @env['async.close'] and async_close.succeed
     @deferred.respond_to?(:fail) and @deferred.fail
     begin
       @_io.close