rainbows 3.0.0 → 3.1.0

data/lib/rainbows/ev_core.rb

@@ -7,6 +7,8 @@ module Rainbows::EvCore
   NULL_IO = Unicorn::HttpRequest::NULL_IO
   HttpParser = Rainbows::HttpParser
   autoload :CapInput, 'rainbows/ev_core/cap_input'
+  RBUF = ""
+  Z = "".freeze
 
   # Apps may return this Rack response: AsyncResponse = [ -1, {}, [] ]
   ASYNC_CALLBACK = "async.callback".freeze
@@ -54,7 +56,7 @@ module Rainbows::EvCore
       rv = false
     else
       rv = !!(headers[Transfer_Encoding] =~ %r{\Achunked\z}i)
-      rv = false if headers.delete('X-Rainbows-Autochunk') == 'no'
+      rv = false unless @env["rainbows.autochunk"]
     end
     write_headers(status, headers, alive)
     rv
@@ -70,7 +72,7 @@ module Rainbows::EvCore
     @input = mkinput
     @hp.filter_body(@buf2 = "", @buf)
     @input << @buf2
-    on_read("")
+    on_read(Z)
   end
 
   # TeeInput doesn't map too well to this right now...
@@ -81,8 +83,7 @@ module Rainbows::EvCore
       @hp.parse or return want_more
       @state = :body
       if 0 == @hp.content_length
-        @input = NULL_IO
-        app_call # common case
+        app_call NULL_IO # common case
       else # nil or len > 0
         prepare_request_body
       end
@@ -90,7 +91,7 @@ module Rainbows::EvCore
       if @hp.body_eof?
         if @hp.content_length
           @input.rewind
-          app_call
+          app_call @input
         else
           @state = :trailers
           on_read(data)
@@ -98,14 +99,14 @@ module Rainbows::EvCore
       elsif data.size > 0
         @hp.filter_body(@buf2, @buf << data)
         @input << @buf2
-        on_read("")
+        on_read(Z)
       else
         want_more
       end
     when :trailers
       if @hp.trailers(@env, @buf << data)
         @input.rewind
-        app_call
+        app_call @input
       else
         want_more
       end
@@ -114,14 +115,17 @@ module Rainbows::EvCore
       handle_error(e)
   end
 
+  ERROR_413_RESPONSE = "HTTP/1.1 413 Request Entity Too Large\r\n\r\n"
+
   def err_413(msg)
-    write(Rainbows::Const::ERROR_413_RESPONSE)
+    write(ERROR_413_RESPONSE)
     quit
     # zip back up the stack
     raise IOError, msg, []
   end
 
   TmpIO = Unicorn::TmpIO
+  CBB = Unicorn::TeeInput.client_body_buffer_size
 
   def io_for(bytes)
     bytes <= CBB ? StringIO.new("") : TmpIO.new
@@ -139,8 +143,4 @@ module Rainbows::EvCore
       max ? CapInput.new(io_for(max), self, max) : TmpIO.new
     end
   end
-
-  def self.setup
-    const_set :CBB, Unicorn::TeeInput.client_body_buffer_size
-  end
 end

data/lib/rainbows/ev_core/cap_input.rb

@@ -15,7 +15,7 @@ class Rainbows::EvCore::CapInput
   end
 
   def gets; @io.gets; end
-  def each(&block); @io.each(&block); end
+  def each; @io.each { |x| yield x }; end
   def size; @io.size; end
   def rewind; @io.rewind; end
   def read(*args); @io.read(*args); end

data/lib/rainbows/event_machine.rb

@@ -48,11 +48,6 @@ module Rainbows::EventMachine
 
   include Rainbows::Base
 
-  def init_worker_process(worker) # :nodoc:
-    Rainbows::Response.setup(Rainbows::EventMachine::Client)
-    super
-  end
-
   # runs inside each forked worker, this sits around and waits
   # for connections and doesn't die until the parent dies (or is
   # given a INT, QUIT, or TERM signal)
@@ -71,7 +66,6 @@ module Rainbows::EventMachine
     Rainbows::EventMachine::Server.const_set(:MAX, max)
     Rainbows::EventMachine::Server.const_set(:CL, client_class)
     client_class.const_set(:APP, Rainbows.server.app)
-    Rainbows::EvCore.setup
     EM.run {
       conns = EM.instance_variable_get(:@conns) or
         raise RuntimeError, "EM @conns instance variable not accessible!"

data/lib/rainbows/event_machine/client.rb

@@ -21,7 +21,7 @@ class Rainbows::EventMachine::Client < EM::Connection
       end
       EM.next_tick { receive_data(nil) } unless @buf.empty?
     else
-      on_read(data || "") if (@buf.size > 0) || data
+      on_read(data || Z) if (@buf.size > 0) || data
     end
   end
 
@@ -30,9 +30,9 @@ class Rainbows::EventMachine::Client < EM::Connection
     close_connection_after_writing
   end
 
-  def app_call
+  def app_call input
     set_comm_inactivity_timeout 0
-    @env[RACK_INPUT] = @input
+    @env[RACK_INPUT] = input
     @env[REMOTE_ADDR] = @_io.kgio_addr
     @env[ASYNC_CALLBACK] = method(:write_async_response)
     @env[ASYNC_CLOSE] = EM::DefaultDeferrable.new

data/lib/rainbows/event_machine/response_chunk_pipe.rb

@@ -9,17 +9,15 @@ module Rainbows::EventMachine::ResponseChunkPipe
   end
 
   def notify_readable
-    begin
-      data = @io.read_nonblock(16384, BUF)
+    case data = Kgio.tryread(@io, 16384, RBUF)
+    when String
       @client.write("#{data.size.to_s(16)}\r\n")
       @client.write(data)
       @client.write("\r\n")
-    rescue Errno::EINTR
-    rescue Errno::EAGAIN
-      return
-    rescue EOFError
-      detach
+    when :wait_readable
       return
+    when nil
+      return detach
     end while true
   end
 end

data/lib/rainbows/event_machine/response_pipe.rb

@@ -3,21 +3,20 @@
 module Rainbows::EventMachine::ResponsePipe
   # garbage avoidance, EM always uses this in a single thread,
   # so a single buffer for all clients will work safely
-  BUF = ''
+  RBUF = Rainbows::EvCore::RBUF
 
   def initialize(client)
     @client = client
   end
 
   def notify_readable
-    begin
-      @client.write(@io.read_nonblock(16384, BUF))
-    rescue Errno::EINTR
-    rescue Errno::EAGAIN
-      return
-    rescue EOFError
-      detach
+    case data = Kgio.tryread(@io, 16384, RBUF)
+    when String
+      @client.write(data)
+    when :wait_readable
       return
+    when nil
+      return detach
     end while true
   end
 

data/lib/rainbows/fiber/base.rb

@@ -17,7 +17,7 @@ module Rainbows::Fiber::Base
   # schedules ones that were blocked on I/O.  At most it'll sleep
   # for one second (returned by the schedule_sleepers method) which
   # will cause it.
-  def schedule(&block)
+  def schedule
     begin
       Rainbows.tick
       t = schedule_sleepers
@@ -33,7 +33,7 @@ module Rainbows::Fiber::Base
     ret[1].concat(RD.compact & ret[0]).each { |c| c.f.resume }
 
     # accept is an expensive syscall, filter out listeners we don't want
-    (ret[0] & LISTENERS).each(&block)
+    (ret[0] & LISTENERS).each { |x| yield x }
   end
 
   # wakes up any sleepers or keepalive-timeout violators that need to be

data/lib/rainbows/fiber/io.rb

@@ -28,7 +28,7 @@ class Rainbows::Fiber::IO
   end
 
   # for wrapping output response bodies
-  def each(&block)
+  def each
     buf = readpartial(16384)
     yield buf
     yield buf while readpartial(16384, buf)
@@ -45,78 +45,36 @@ class Rainbows::Fiber::IO
   end
 
   def write(buf)
-    if @to_io.respond_to?(:kgio_trywrite)
-      begin
-        case rv = @to_io.kgio_trywrite(buf)
-        when nil
-          return
-        when String
-          buf = rv
-        when :wait_writable
-          kgio_wait_writable
-        end
-      end while true
-    else
-      begin
-        (rv = @to_io.write_nonblock(buf)) == buf.bytesize and return
-        buf = byte_slice(buf, rv)
-      rescue Errno::EAGAIN
-        kgio_wait_writable
-      end while true
-    end
-  end
-
-  def byte_slice(buf, start) # :nodoc:
-    buf.encoding == Encoding::BINARY or
-      buf = buf.dup.force_encoding(Encoding::BINARY)
-    buf.slice(start, buf.size)
+    case rv = Kgio.trywrite(buf)
+    when String
+      buf = rv
+    when :wait_writable
+      kgio_wait_writable
+    end until nil == rv
   end
 
   # used for reading headers (respecting keepalive_timeout)
   def timed_read(buf)
     expire = nil
-    if @to_io.respond_to?(:kgio_tryread)
-      begin
-        case rv = @to_io.kgio_tryread(16384, buf)
-        when :wait_readable
-          return if expire && expire < Time.now
-          expire ||= read_expire
-          kgio_wait_readable
-        else
-          return rv
-        end
-      end while true
+    case rv = Kgio.tryread(@to_io, 16384, buf)
+    when :wait_readable
+      return if expire && expire < Time.now
+      expire ||= read_expire
+      kgio_wait_readable
     else
-      begin
-        return @to_io.read_nonblock(16384, buf)
-      rescue Errno::EAGAIN
-        return if expire && expire < Time.now
-        expire ||= read_expire
-        kgio_wait_readable
-      end while true
-    end
+      return rv
+    end while true
   end
 
   def readpartial(length, buf = "")
-    if @to_io.respond_to?(:kgio_tryread)
-      begin
-        rv = @to_io.kgio_tryread(length, buf)
-        case rv
-        when nil
-          raise EOFError, "end of file reached", []
-        when :wait_readable
-          kgio_wait_readable
-        else
-          return rv
-        end
-      end while true
+    case rv = Kgio.tryread(@to_io, length, buf)
+    when nil
+      raise EOFError, "end of file reached", []
+    when :wait_readable
+      kgio_wait_readable
     else
-      begin
-        return @to_io.read_nonblock(length, buf)
-      rescue Errno::EAGAIN
-        kgio_wait_readable
-      end while true
-    end
+      return rv
+    end while true
   end
 
   def kgio_read(*args)

data/lib/rainbows/fiber/io/methods.rb

@@ -16,7 +16,7 @@ module Rainbows::Fiber::IO::Methods
   end
 
   # for wrapping output response bodies
-  def each(&block)
+  def each
     if buf = kgio_read(16384)
       yield buf
       yield buf while kgio_read(16384, buf)

data/lib/rainbows/http_server.rb

@@ -43,7 +43,7 @@ class Rainbows::HttpServer < Unicorn::HttpServer
 
   def ready_pipe=(v)
     # hacky hook got force Rainbows! to load modules only in workers
-    if @master_pid && @master_pid == Process.ppid
+    if defined?(@master_pid) && @master_pid == Process.ppid
       extend(Rainbows.const_get(@use))
     end
     super
@@ -63,8 +63,8 @@ class Rainbows::HttpServer < Unicorn::HttpServer
       raise ArgumentError, "concurrency model #{model.inspect} not supported"
     args.each do |opt|
       case opt
-      when Hash; O.update(opt)
-      when Symbol; O[opt] = true
+      when Hash; Rainbows::O.update(opt)
+      when Symbol; Rainbows::O[opt] = true
       else; raise ArgumentError, "can't handle option: #{opt.inspect}"
       end
     end
@@ -72,7 +72,7 @@ class Rainbows::HttpServer < Unicorn::HttpServer
     new_defaults = {
       'rainbows.model' => (@use = model.to_sym),
       'rack.multithread' => !!(model.to_s =~ /Thread/),
-      'rainbows.autochunk' => [:Coolio,:Rev,
+      'rainbows.autochunk' => [:Coolio,:Rev,:Epoll,:XEpoll,
                                :EventMachine,:NeverBlock].include?(@use),
     }
     Rainbows::Const::RACK_DEFAULTS.update(new_defaults)

data/lib/rainbows/join_threads.rb

@@ -0,0 +1,18 @@
+# -*- encoding: binary -*-
+# :enddoc:
+# This module only gets loaded on shutdown
+module Rainbows::JoinThreads
+
+  # blocking acceptor threads must be forced to run
+  def self.acceptors(threads)
+    threads.delete_if do |thr|
+      Rainbows.tick
+      begin
+        thr.run
+        thr.join(0.01)
+      rescue
+        true
+      end
+    end until threads.empty?
+  end
+end

data/lib/rainbows/max_body.rb

@@ -55,7 +55,8 @@ class Rainbows::MaxBody
     case Rainbows.server.use
     when :Rev, :Coolio, :EventMachine, :NeverBlock,
          :RevThreadSpawn, :RevThreadPool,
-         :CoolioThreadSpawn, :CoolioThreadPool
+         :CoolioThreadSpawn, :CoolioThreadPool,
+         :Epoll, :XEpoll
       return
     end
 

data/lib/rainbows/max_body/wrapper.rb

@@ -7,7 +7,7 @@ class Rainbows::MaxBody::Wrapper
     @input, @limit, @rbuf = rack_input, limit, ''
   end
 
-  def each(&block)
+  def each
     while line = gets
       yield line
     end

data/lib/rainbows/never_block/event_machine.rb

@@ -1,10 +1,10 @@
 # -*- encoding: binary -*-
 # :enddoc:
 class Rainbows::NeverBlock::Client < Rainbows::EventMachine::Client
-  def app_call
+  def app_call input
     POOL.spawn do
       begin
-        super
+        super input
       rescue => e
         handle_error(e)
       end

data/lib/rainbows/process_client.rb

@@ -1,9 +1,13 @@
 # -*- encoding: binary -*-
+# :enddoc:
 module Rainbows::ProcessClient
   include Rainbows::Response
-  include Rainbows::RackInput
   include Rainbows::Const
 
+  NULL_IO = Unicorn::HttpRequest::NULL_IO
+  RACK_INPUT = Unicorn::HttpRequest::RACK_INPUT
+  IC = Unicorn::HttpRequest.input_class
+
   def process_loop
     @hp = hp = Rainbows::HttpParser.new
     kgio_read!(16384, buf = hp.buf) or return
@@ -38,4 +42,8 @@ module Rainbows::ProcessClient
   def handle_error(e)
     Rainbows::Error.write(self, e)
   end
+
+  def set_input(env, hp)
+    env[RACK_INPUT] = 0 == hp.content_length ? NULL_IO : IC.new(self, hp)
+  end
 end

data/lib/rainbows/queue_pool.rb

@@ -6,12 +6,12 @@ require 'thread'
 # This is NOT used for the ThreadPool class, since that class does not
 # need a userspace Queue.
 class Rainbows::QueuePool < Struct.new(:queue, :threads)
-  def initialize(size = 20, &block)
+  def initialize(size = 20)
     q = Queue.new
     self.threads = (1..size).map do
       Thread.new do
         while job = q.shift
-          block.call(job)
+          yield job
         end
       end
     end