rainbows 4.7.0 → 5.0.0

data/lib/rainbows/event_machine/try_defer.rb

@@ -10,9 +10,6 @@
 # See http://brainspl.at/articles/2008/04/18/deferred-requests-with-merb-ebb-and-thin
 # for more information.
 class Rainbows::EventMachine::TryDefer
-  # shortcuts
-  ASYNC_CALLBACK = Rainbows::EvCore::ASYNC_CALLBACK # :nodoc:
-
   def initialize(app) # :nodoc:
     # the entire app becomes multithreaded, even the root (non-deferred)
     # thread since any thread can share processes with others
@@ -22,7 +19,7 @@ def initialize(app) # :nodoc:
 
   def call(env) # :nodoc:
     if @app.deferred?(env)
-      EM.defer(proc { catch(:async) { @app.call(env) } }, env[ASYNC_CALLBACK])
+      EM.defer(proc { catch(:async) { @app.call(env) } }, env['async.callback'])
       # all of the async/deferred stuff breaks Rack::Lint :<
       nil
     else

data/lib/rainbows/fiber.rb

@@ -29,7 +29,7 @@ module Rainbows::Fiber
   # right?).  Calling this directly is deprecated, use
   # Rainbows.sleep(seconds) instead.
   def self.sleep(seconds)
-    ZZ[Fiber.current] = Time.now + seconds
+    ZZ[Fiber.current] = Rainbows.now + seconds
     Fiber.yield
   end
 

data/lib/rainbows/fiber/base.rb

@@ -40,7 +40,7 @@ def schedule
   # woken and returns an interval to IO.select on
   def schedule_sleepers
     max = nil
-    now = Time.now
+    now = Rainbows.now
     fibs = []
     ZZ.delete_if { |fib, time|
       if now >= time
@@ -50,11 +50,11 @@ def schedule_sleepers
         false
       end
     }
-    fibs.each { |fib| fib.resume }
+    fibs.each(&:resume)
 
     max_sleep = 1.0 # wake up semi-frequently to prevent SIGKILL from master
     if max
-      max -= Time.now
+      max -= Rainbows.now
       return 0 if max < 0.0
       return max_sleep if max > max_sleep
       max

data/lib/rainbows/fiber/coolio/heartbeat.rb

@@ -5,7 +5,7 @@ class Rainbows::Fiber::Coolio::Heartbeat < Coolio::TimerWatcher
   ZZ = Rainbows::Fiber::ZZ
   def on_timer
     exit if (! Rainbows.tick && Rainbows.cur <= 0)
-    now = Time.now
+    now = Rainbows.now
     fibs = []
     ZZ.delete_if { |fib, time| now >= time ? fibs << fib : ! fib.alive? }
     fibs.each { |fib| fib.resume if fib.alive? }

data/lib/rainbows/fiber/io.rb

@@ -63,7 +63,7 @@ def timed_read(buf)
     expire = nil
     case rv = Kgio.tryread(@to_io, 16384, buf)
     when :wait_readable
-      return if expire && expire < Time.now
+      return if expire && expire < Rainbows.now
       expire ||= read_expire
       kgio_wait_readable
     else

data/lib/rainbows/http_parser.rb

@@ -2,6 +2,30 @@
 # :enddoc:
 # avoid modifying Unicorn::HttpParser
 class Rainbows::HttpParser < Unicorn::HttpParser
+  @keepalive_requests = 100
+  class << self
+    attr_accessor :keepalive_requests
+  end
+
+  def initialize(*args)
+    @keepalive_requests = self.class.keepalive_requests
+    super
+  end
+
+  def next?
+    return false if (@keepalive_requests -= 1) <= 0
+    super
+  end
+
+  def hijack_setup(io)
+    @hijack_io = io
+    env['rack.hijack'] = self # avoid allocating a new proc this way
+  end
+
+  def call # for rack.hijack
+    env['rack.hijack_io'] = @hijack_io
+  end
+
   def self.quit
     alias_method :next?, :never!
   end

data/lib/rainbows/http_server.rb

@@ -8,6 +8,7 @@ class Rainbows::HttpServer < Unicorn::HttpServer
   attr_accessor :client_header_buffer_size
   attr_accessor :client_max_body_size
   attr_reader :use
+  attr_reader :master_pid
 
   def self.setup(block)
     Rainbows.server.instance_eval(&block)
@@ -81,10 +82,10 @@ def svc
   end
 
   def use=(mod)
-    @use = mod.to_s.split(/::/)[-1].to_sym
+    @use = mod.to_s.split('::')[-1].to_sym
     new_defaults = {
       'rainbows.model' => @use,
-      'rack.multithread' => !!(mod.to_s =~ /Thread/),
+      'rack.multithread' => mod.to_s.include?('Thread'),
       'rainbows.autochunk' => [:Coolio,:Rev,:Epoll,:XEpoll,
                                :EventMachine,:NeverBlock].include?(@use),
     }
@@ -92,11 +93,11 @@ def use=(mod)
   end
 
   def keepalive_requests=(nr)
-    Unicorn::HttpRequest.keepalive_requests = nr
+    Rainbows::HttpParser.keepalive_requests = nr
   end
 
   def keepalive_requests
-    Unicorn::HttpRequest.keepalive_requests
+    Rainbows::HttpParser.keepalive_requests
   end
 
   def client_max_header_size=(bytes)

data/lib/rainbows/join_threads.rb

@@ -5,12 +5,12 @@ module Rainbows::JoinThreads
 
   # blocking acceptor threads must be forced to run
   def self.acceptors(threads)
-    expire = Time.now + Rainbows.server.timeout
+    expire = Rainbows.now + Rainbows.server.timeout
     threads.delete_if do |thr|
       Rainbows.tick
       begin
         # blocking accept() may not wake up properly
-        thr.raise(Errno::EINTR) if Time.now > expire && thr.stop?
+        thr.raise(Errno::EINTR) if Rainbows.now > expire && thr.stop?
 
         thr.run
         thr.join(0.01)

data/lib/rainbows/max_body.rb

@@ -48,19 +48,14 @@ def initialize(app, limit = nil)
     @app, @limit = app, limit
   end
 
-  # :stopdoc:
-  RACK_INPUT = "rack.input".freeze
-  CONTENT_LENGTH = "CONTENT_LENGTH"
-  HTTP_TRANSFER_ENCODING = "HTTP_TRANSFER_ENCODING"
-
   # our main Rack middleware endpoint
   def call(env)
     @limit = Rainbows.server.client_max_body_size if nil == @limit
     catch(:rainbows_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)
@@ -89,9 +84,9 @@ def err # :nodoc:
   end
 
   def limit_input!(env)
-    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
 
   # :startdoc:

data/lib/rainbows/process_client.rb

@@ -5,12 +5,11 @@ module Rainbows::ProcessClient
   include Rainbows::Const
 
   NULL_IO = Unicorn::HttpRequest::NULL_IO
-  RACK_INPUT = Unicorn::HttpRequest::RACK_INPUT
   IC = Unicorn::HttpRequest.input_class
   Rainbows.config!(self, :client_header_buffer_size, :keepalive_timeout)
 
   def read_expire
-    Time.now + KEEPALIVE_TIMEOUT
+    Rainbows.now + KEEPALIVE_TIMEOUT
   end
 
   # used for reading headers (respecting keepalive_timeout)
@@ -19,7 +18,7 @@ def timed_read(buf)
     begin
       case rv = kgio_tryread(CLIENT_HEADER_BUFFER_SIZE, buf)
       when :wait_readable
-        return if expire && expire < Time.now
+        return if expire && expire < Rainbows.now
         expire ||= read_expire
         kgio_wait_readable(KEEPALIVE_TIMEOUT)
       else
@@ -39,13 +38,13 @@ def process_loop
       end
 
       set_input(env, hp)
-      env[REMOTE_ADDR] = kgio_addr
-      hp.hijack_setup(env, to_io)
+      env['REMOTE_ADDR'] = kgio_addr
+      hp.hijack_setup(to_io)
       status, headers, body = APP.call(env.merge!(RACK_DEFAULTS))
 
       if 100 == status.to_i
-        write(EXPECT_100_RESPONSE)
-        env.delete(HTTP_EXPECT)
+        write("HTTP/1.1 100 Continue\r\n\r\n".freeze)
+        env.delete('HTTP_EXPECT'.freeze)
         status, headers, body = APP.call(env)
       end
       return if hp.hijacked?
@@ -66,18 +65,18 @@ def handle_error(e)
   end
 
   def set_input(env, hp)
-    env[RACK_INPUT] = 0 == hp.content_length ? NULL_IO : IC.new(self, hp)
+    env['rack.input'] = 0 == hp.content_length ? NULL_IO : IC.new(self, hp)
   end
 
   def process_pipeline(env, hp)
     begin
       set_input(env, hp)
-      env[REMOTE_ADDR] = kgio_addr
-      hp.hijack_setup(env, to_io)
+      env['REMOTE_ADDR'] = kgio_addr
+      hp.hijack_setup(to_io)
       status, headers, body = APP.call(env.merge!(RACK_DEFAULTS))
       if 100 == status.to_i
-        write(EXPECT_100_RESPONSE)
-        env.delete(HTTP_EXPECT)
+        write("HTTP/1.1 100 Continue\r\n\r\n".freeze)
+        env.delete('HTTP_EXPECT'.freeze)
         status, headers, body = APP.call(env)
       end
       return if hp.hijacked?

data/lib/rainbows/response.rb

@@ -2,10 +2,6 @@
 # :enddoc:
 module Rainbows::Response
   include Unicorn::HttpResponse
-  Close = "close"
-  KeepAlive = "keep-alive"
-  Content_Length = "Content-Length".freeze
-  Transfer_Encoding = "Transfer-Encoding".freeze
   Rainbows.config!(self, :copy_stream)
 
   # private file class for IO objects opened by Rainbows! itself (and not
@@ -19,20 +15,8 @@ def self.setup
       Rainbows::HttpParser.keepalive_requests = 0
   end
 
-  # Rack 1.5.0 (protocol version 1.2) adds response hijacking support
-  if ((Rack::VERSION[0] << 8) | Rack::VERSION[1]) >= 0x0102
-    RACK_HIJACK = "rack.hijack"
-
-    def hijack_prepare(value)
-      value
-    end
-
-    def hijack_socket
-      @hp.env[RACK_HIJACK].call
-    end
-  else
-    def hijack_prepare(_)
-    end
+  def hijack_socket
+    @hp.env['rack.hijack'].call
   end
 
   # returns the original body on success
@@ -40,29 +24,30 @@ def hijack_prepare(_)
   def write_headers(status, headers, alive, body)
     @hp.headers? or return body
     hijack = nil
-    status = CODES[status.to_i] || status
-    buf = "HTTP/1.1 #{status}\r\n" \
-          "Date: #{httpdate}\r\n" \
-          "Status: #{status}\r\n"
+    code = status.to_i
+    msg = Rack::Utils::HTTP_STATUS_CODES[code]
+    buf = "HTTP/1.1 #{msg ? %Q(#{code} #{msg}) : status}\r\n" \
+          "Date: #{httpdate}\r\n"
     headers.each do |key, value|
       case key
-      when %r{\A(?:Date\z|Connection\z)}i
+      when %r{\A(?:Date|Connection)\z}i
         next
       when "rack.hijack"
         # this was an illegal key in Rack < 1.5, so it should be
         # OK to silently discard it for those older versions
-        hijack = hijack_prepare(value)
+        hijack = value
         alive = false # No persistent connections for hijacking
       else
         if /\n/ =~ value
           # avoiding blank, key-only cookies with /\n+/
-          buf << value.split(/\n+/).map! { |v| "#{key}: #{v}\r\n" }.join
+          value.split(/\n+/).each { |v| buf << "#{key}: #{v}\r\n" }
         else
           buf << "#{key}: #{value}\r\n"
         end
       end
     end
-    write(buf << "Connection: #{alive ? KeepAlive : Close}\r\n\r\n")
+    write(buf << (alive ? "Connection: keep-alive\r\n\r\n".freeze
+                        : "Connection: close\r\n\r\n".freeze))
 
     if hijack
       body = nil # ensure caller does not close body
@@ -152,30 +137,27 @@ def write_body_stream(body)
   end  # ! COPY_STREAM
 
   if IO.method_defined?(:trysendfile) || COPY_STREAM
-    HTTP_RANGE = 'HTTP_RANGE'
-    Content_Range = 'Content-Range'.freeze
-
     # This does not support multipart responses (does anybody actually
     # use those?)
     def sendfile_range(status, headers)
       status = status.to_i
       if 206 == status
-        if %r{\Abytes (\d+)-(\d+)/\d+\z} =~ headers[Content_Range]
+        if %r{\Abytes (\d+)-(\d+)/\d+\z} =~ headers['Content-Range'.freeze]
           a, b = $1.to_i, $2.to_i
           return 206, headers, [ a,  b - a + 1 ]
         end
         return # wtf...
       end
       200 == status &&
-      /\Abytes=(\d+-\d*|\d*-\d+)\z/ =~ @hp.env[HTTP_RANGE] or
+      /\Abytes=(\d+-\d*|\d*-\d+)\z/ =~ @hp.env['HTTP_RANGE'] or
         return
-      a, b = $1.split(/-/)
+      a, b = $1.split('-'.freeze)
 
       # HeaderHash is quite expensive, and Rack::File currently
       # uses a regular Ruby Hash with properly-cased headers the
       # same way they're presented in rfc2616.
       headers = Rack::Utils::HeaderHash.new(headers) unless Hash === headers
-      clen = headers[Content_Length] or return
+      clen = headers['Content-Length'.freeze] or return
       size = clen.to_i
 
       if b.nil? # bytes=M-
@@ -190,13 +172,14 @@ def sendfile_range(status, headers)
       end
 
       if 0 > count || offset >= size
-        headers[Content_Length] = "0"
-        headers[Content_Range] = "bytes */#{clen}"
+        headers['Content-Length'.freeze] = "0"
+        headers['Content-Range'.freeze] = "bytes */#{clen}"
         return 416, headers, nil
       else
         count = size if count > size
-        headers[Content_Length] = count.to_s
-        headers[Content_Range] = "bytes #{offset}-#{offset+count-1}/#{clen}"
+        headers['Content-Length'.freeze] = count.to_s
+        headers['Content-Range'.freeze] =
+                                    "bytes #{offset}-#{offset+count-1}/#{clen}"
         return 206, headers, [ offset, count ]
       end
     end

data/lib/rainbows/revactor.rb

@@ -1,6 +1,5 @@
 # -*- encoding: binary -*-
 require 'revactor'
-require 'fcntl'
 Revactor::VERSION >= '0.1.5' or abort 'revactor 0.1.5 is required'
 
 # Enables use of the Actor model through {Revactor}[http://revactor.org]

data/lib/rainbows/revactor/client.rb

@@ -1,6 +1,5 @@
 # -*- encoding: binary -*-
 # :enddoc:
-require 'fcntl'
 class Rainbows::Revactor::Client
   autoload :TeeSocket, 'rainbows/revactor/client/tee_socket'
   RD_ARGS = {}
@@ -11,7 +10,7 @@ class Rainbows::Revactor::Client
   def initialize(client)
     @client, @rd_args, @ts = client, [ nil ], nil
     io = client.instance_variable_get(:@_io)
-    io.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+    io.close_on_exec = true
     @kgio_addr = if Revactor::TCP::Socket === client
       @rd_args << RD_ARGS
       client.remote_addr
@@ -33,7 +32,7 @@ def timed_read(buf2)
   end
 
   def set_input(env, hp)
-    env[RACK_INPUT] = 0 == hp.content_length ?
+    env['rack.input'] = 0 == hp.content_length ?
                       NULL_IO : IC.new(@ts = TeeSocket.new(@client), hp)
   end
 

data/lib/rainbows/revactor/proxy.rb

@@ -22,7 +22,7 @@ def each
     # (instead of Errno::EPIPE), so we need to limit the rescue
     # to just readpartial and let EOFErrors during yield bubble up
     begin
-      buf = readpartial(INPUT_SIZE)
+      buf = readpartial(16384)
     rescue EOFError
       break
     end while yield(buf) || true

data/lib/rainbows/reverse_proxy.rb

@@ -47,15 +47,6 @@ class Rainbows::ReverseProxy
   autoload :EventMachine, 'rainbows/reverse_proxy/event_machine'
   autoload :EvClient, 'rainbows/reverse_proxy/ev_client'
 
-  HTTP_X_FORWARDED_FOR = "HTTP_X_FORWARDED_FOR"
-  REMOTE_ADDR = "REMOTE_ADDR"
-  REQUEST_METHOD = "REQUEST_METHOD"
-  REQUEST_URI = "REQUEST_URI"
-  CRLF = "\r\n"
-  TR = %w(_ -)
-  CONTENT_LENGTH = "CONTENT_LENGTH"
-  HTTP_TRANSFER_ENCODING = "HTTP_TRANSFER_ENCODING"
-  RackInput = "rack.input"
   E502 = [ 502, [ %w(Content-Length 0), %w(Content-Type text/plain) ], [] ]
 
   def initialize(opts)
@@ -113,24 +104,23 @@ def call(env)
 
   # returns request headers for sending to the upstream as a string
   def build_headers(env, input)
-    remote_addr = env[REMOTE_ADDR]
-    xff = env[HTTP_X_FORWARDED_FOR]
+    remote_addr = env['REMOTE_ADDR']
+    xff = env['HTTP_X_FORWARDED_FOR']
     xff = xff ? "#{xff},#{remote_addr}" : remote_addr
-    req = "#{env[REQUEST_METHOD]} #{env[REQUEST_URI]} HTTP/1.0\r\n" \
+    req = "#{env['REQUEST_METHOD']} #{env['REQUEST_URI']} HTTP/1.0\r\n" \
           "Connection: close\r\n" \
           "X-Forwarded-For: #{xff}\r\n"
-    uscore, dash = *TR
     env.each do |key, value|
       %r{\AHTTP_(\w+)\z} =~ key or next
       key = $1
       next if %r{\A(?:VERSION|CONNECTION|KEEP_ALIVE|X_FORWARDED_FOR)\z}x =~ key
-      key.tr!(uscore, dash)
+      key.tr!('_'.freeze, '-'.freeze)
       req << "#{key}: #{value}\r\n"
     end
     input and req << (input.respond_to?(:size) ?
                      "Content-Length: #{input.size}\r\n" :
-                     "Transfer-Encoding: chunked\r\n")
-    req << CRLF
+                     "Transfer-Encoding: chunked\r\n".freeze)
+    req << "\r\n".freeze
   end
 
   def pick_upstream(env) # +env+ is reserved for future expansion
@@ -139,16 +129,16 @@ def pick_upstream(env) # +env+ is reserved for future expansion
   end
 
   def prepare_input!(env)
-    if cl = env[CONTENT_LENGTH]
+    if cl = env['CONTENT_LENGTH']
       size = cl.to_i
       size > 0 or return
-    elsif %r{\Achunked\z}i =~ env.delete(HTTP_TRANSFER_ENCODING)
+    elsif %r{\Achunked\z}i =~ env.delete('HTTP_TRANSFER_ENCODING')
       # do people use multiple transfer-encodings?
     else
       return
     end
 
-    input = env[RackInput]
+    input = env['rack.input']
     if input.respond_to?(:rewind)
       if input.respond_to?(:size)
         input.size # TeeInput-specific behavior