rainbows 2.0.1 → 2.1.0

data/lib/rainbows/coolio_thread_pool.rb

@@ -0,0 +1,57 @@
+# -*- encoding: binary -*-
+
+# A combination of the Coolio and ThreadPool models.  This allows Ruby
+# Thread-based concurrency for application processing.  It DOES NOT
+# expose a streamable "rack.input" for upload processing within the
+# app.  DevFdResponse should be used with this class to proxy
+# asynchronous responses.  All network I/O between the client and
+# server are handled by the main thread and outside of the core
+# application dispatch.
+#
+# Unlike ThreadPool, Cool.io makes this model highly suitable for
+# slow clients and applications with medium-to-slow response times
+# (I/O bound), but less suitable for sleepy applications.
+#
+# This concurrency model is designed for Ruby 1.9, and Ruby 1.8
+# users are NOT advised to use this due to high CPU usage.
+module Rainbows::CoolioThreadPool
+  # :stopdoc:
+  DEFAULTS = {
+    :pool_size => 20, # same default size as ThreadPool (w/o Coolio)
+  }
+  #:startdoc:
+
+  def self.setup # :nodoc:
+    o = Rainbows::O
+    DEFAULTS.each { |k,v| o[k] ||= v }
+    Integer === o[:pool_size] && o[:pool_size] > 0 or
+      raise ArgumentError, "pool_size must a be an Integer > 0"
+  end
+  include Rainbows::Coolio::Core
+
+  def init_worker_threads(master, queue) # :nodoc:
+    Rainbows::O[:pool_size].times.map do
+      Thread.new do
+        begin
+          client = queue.pop
+          master << [ client, client.app_response ]
+        rescue => e
+          Rainbows::Error.listen_loop(e)
+        end while true
+      end
+    end
+  end
+
+  def init_worker_process(worker) # :nodoc:
+    super
+    cloop = Coolio::Loop.default
+    master = Rainbows::Coolio::Master.new(Queue.new).attach(cloop)
+    queue = Client.const_set(:QUEUE, Queue.new)
+    threads = init_worker_threads(master, queue)
+    Watcher.new(threads).attach(cloop)
+    logger.info "CoolioThreadPool pool_size=#{Rainbows::O[:pool_size]}"
+  end
+end
+# :enddoc:
+require 'rainbows/coolio_thread_pool/client'
+require 'rainbows/coolio_thread_pool/watcher'

data/lib/rainbows/coolio_thread_spawn/client.rb

@@ -0,0 +1,8 @@
+# -*- encoding: binary -*-
+# :enddoc:
+class Rainbows::CoolioThreadSpawn::Client < Rainbows::Coolio::ThreadClient
+  # MASTER will be set in worker_loop
+  def app_dispatch
+    Thread.new(self) { |client| MASTER << [ client, app_response ] }
+  end
+end

data/lib/rainbows/coolio_thread_spawn.rb

@@ -0,0 +1,27 @@
+# -*- encoding: binary -*-
+# A combination of the Coolio and ThreadSpawn models.  This allows Ruby
+# Thread-based concurrency for application processing.  It DOES NOT
+# expose a streamable "rack.input" for upload processing within the
+# app.  DevFdResponse should be used with this class to proxy
+# asynchronous responses.  All network I/O between the client and
+# server are handled by the main thread and outside of the core
+# application dispatch.
+#
+# Unlike ThreadSpawn, Cool.io makes this model highly suitable for
+# slow clients and applications with medium-to-slow response times
+# (I/O bound), but less suitable for sleepy applications.
+#
+# This concurrency model is designed for Ruby 1.9, and Ruby 1.8
+# users are NOT advised to use this due to high CPU usage.
+module Rainbows::CoolioThreadSpawn
+  include Rainbows::Coolio::Core
+
+  def init_worker_process(worker) # :nodoc:
+    super
+    master = Rainbows::Coolio::Master.new(Queue.new)
+    master.attach(Coolio::Loop.default)
+    Client.const_set(:MASTER, master)
+  end
+end
+# :enddoc:
+require 'rainbows/coolio_thread_spawn/client'

data/lib/rainbows/dev_fd_response.rb

@@ -29,7 +29,11 @@ class Rainbows::DevFdResponse < Struct.new(:app)
     status, headers, body = response = app.call(env)
 
     # totally uninteresting to us if there's no body
-    return response if STATUS_WITH_NO_ENTITY_BODY.include?(status)
+    if STATUS_WITH_NO_ENTITY_BODY.include?(status.to_i) ||
+       File === body ||
+       (body.respond_to?(:to_path) && File.file?(body.to_path))
+      return response
+    end
 
     io = body.to_io if body.respond_to?(:to_io)
     io ||= File.open(body.to_path) if body.respond_to?(:to_path)
@@ -53,7 +57,7 @@ class Rainbows::DevFdResponse < Struct.new(:app)
 
       # we need to make sure our pipe output is Fiber-compatible
       case env["rainbows.model"]
-      when :FiberSpawn, :FiberPool, :RevFiberSpawn
+      when :FiberSpawn, :FiberPool, :RevFiberSpawn, :CoolioFiberSpawn
         io.respond_to?(:kgio_wait_readable) or
           io = Rainbows::Fiber::IO.new(io)
       when :Revactor

data/lib/rainbows/ev_core/cap_input.rb

@@ -1,8 +1,9 @@
 # -*- encoding: binary -*-
 # :enddoc:
 class Rainbows::EvCore::CapInput
-  def initialize(io, client)
-    @io, @client, @bytes_left = io, client, Rainbows.max_bytes
+
+  def initialize(io, client, max)
+    @io, @client, @bytes_left = io, client, max
   end
 
   def <<(buf)

data/lib/rainbows/ev_core.rb

@@ -86,6 +86,8 @@ module Rainbows::EvCore
         @hp.filter_body(@buf2, @buf << data)
         @input << @buf2
         on_read("")
+      else
+        want_more
       end
     when :trailers
       if @hp.trailers(@env, @buf << data)
@@ -106,8 +108,12 @@ module Rainbows::EvCore
     raise IOError, msg, []
   end
 
-  MAX_BODY = Unicorn::Const::MAX_BODY
   TmpIO = Unicorn::TmpIO
+
+  def io_for(bytes)
+    bytes <= CBB ? StringIO.new("") : TmpIO.new
+  end
+
   def mkinput
     max = Rainbows.max_bytes
     len = @hp.content_length
@@ -115,9 +121,13 @@ module Rainbows::EvCore
       if max && (len > max)
         err_413("Content-Length too big: #{len} > #{max}")
       end
-      len <= MAX_BODY ? StringIO.new("") : TmpIO.new
+      io_for(len)
     else
-      max ? CapInput.new(TmpIO.new, self) : TmpIO.new
+      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/event_machine/client.rb

@@ -0,0 +1,124 @@
+# -*- encoding: binary -*-
+# :enddoc:
+class Rainbows::EventMachine::Client < EM::Connection
+  attr_writer :body
+  include Rainbows::EvCore
+
+  def initialize(io)
+    @_io = io
+    @body = nil
+  end
+
+  alias write send_data
+
+  def receive_data(data)
+    # To avoid clobbering the current streaming response
+    # (often a static file), we do not attempt to process another
+    # request on the same connection until the first is complete
+    if @body
+      if data
+        @buf << data
+        @_io.shutdown(Socket::SHUT_RD) if @buf.size > 0x1c000
+      end
+      EM.next_tick { receive_data(nil) } unless @buf.empty?
+    else
+      on_read(data || "") if (@buf.size > 0) || data
+    end
+  end
+
+  def quit
+    super
+    close_connection_after_writing
+  end
+
+  def app_call
+    set_comm_inactivity_timeout 0
+    @env[RACK_INPUT] = @input
+    @env[REMOTE_ADDR] = @_io.kgio_addr
+    @env[ASYNC_CALLBACK] = method(:em_write_response)
+    @env[ASYNC_CLOSE] = EM::DefaultDeferrable.new
+
+    response = catch(:async) { APP.call(@env.update(RACK_DEFAULTS)) }
+
+    # too tricky to support pipelining with :async since the
+    # second (pipelined) request could be a stuck behind a
+    # long-running async response
+    (response.nil? || -1 == response[0]) and return @state = :close
+
+    if @hp.next? && G.alive && G.kato > 0
+      @state = :headers
+      em_write_response(response, true)
+      if @buf.empty?
+        set_comm_inactivity_timeout(G.kato)
+      elsif @body.nil?
+        EM.next_tick { receive_data(nil) }
+      end
+    else
+      em_write_response(response, false)
+    end
+  end
+
+  def em_write_response(response, alive = false)
+    status, headers, body = response
+    if @hp.headers?
+      headers = HH.new(headers)
+      headers[CONNECTION] = alive ? KEEP_ALIVE : CLOSE
+    else
+      headers = nil
+    end
+
+    if body.respond_to?(:errback) && body.respond_to?(:callback)
+      @body = body
+      body.callback { quit }
+      body.errback { quit }
+      # async response, this could be a trickle as is in comet-style apps
+      headers[CONNECTION] = CLOSE if headers
+      alive = true
+    elsif body.respond_to?(:to_path)
+      st = File.stat(path = body.to_path)
+
+      if st.file?
+        write(response_header(status, headers)) if headers
+        @body = stream_file_data(path)
+        @body.errback do
+          body.close if body.respond_to?(:close)
+          quit
+        end
+        @body.callback do
+          body.close if body.respond_to?(:close)
+          @body = nil
+          alive ? receive_data(nil) : quit
+        end
+        return
+      elsif st.socket? || st.pipe?
+        @body = io = body_to_io(body)
+        chunk = stream_response_headers(status, headers) if headers
+        m = chunk ? Rainbows::EventMachine::ResponseChunkPipe :
+                    Rainbows::EventMachine::ResponsePipe
+        return EM.watch(io, m, self, alive, body).notify_readable = true
+      end
+      # char or block device... WTF? fall through to body.each
+    end
+
+    write(response_header(status, headers)) if headers
+    write_body_each(self, body)
+    quit unless alive
+  end
+
+  def next!
+    @hp.keepalive? ? receive_data(@body = nil) : quit
+  end
+
+  def unbind
+    async_close = @env[ASYNC_CLOSE] and async_close.succeed
+    @body.respond_to?(:fail) and @body.fail
+    begin
+      @_io.close
+    rescue Errno::EBADF
+      # EventMachine's EventableDescriptor::Close() may close
+      # the underlying file descriptor without invalidating the
+      # associated IO object on errors, so @_io.closed? isn't
+      # sufficient.
+    end
+  end
+end

data/lib/rainbows/event_machine/response_pipe.rb

@@ -22,9 +22,8 @@ module Rainbows::EventMachine::ResponsePipe
   end
 
   def unbind
-    @client.body = nil
-    @alive ? @client.on_read('') : @client.quit
     @body.close if @body.respond_to?(:close)
+    @client.next!
     @io.close unless @io.closed?
   end
 end

data/lib/rainbows/event_machine/server.rb

@@ -0,0 +1,15 @@
+# -*- encoding: binary -*-
+module Rainbows::EventMachine::Server # :nodoc: all
+  def close
+    detach
+    @io.close
+  end
+
+  # CL, CUR and MAX will be set when worker_loop starts
+  def notify_readable
+    return if CUR.size >= MAX
+    io = @io.kgio_tryaccept or return
+    sig = EM.attach_fd(io.fileno, false)
+    CUR[sig] = CL.new(sig, io)
+  end
+end

data/lib/rainbows/event_machine.rb

@@ -1,7 +1,6 @@
 # -*- encoding: binary -*-
 require 'eventmachine'
 EM::VERSION >= '0.12.10' or abort 'eventmachine 0.12.10 is required'
-require 'rainbows/ev_core'
 
 # Implements a basic single-threaded event model with
 # {EventMachine}[http://rubyeventmachine.com/].  It is capable of
@@ -42,141 +41,11 @@ require 'rainbows/ev_core'
 # "rack.input" will be fully buffered in memory or to a temporary file
 # before the application is entered.
 module Rainbows::EventMachine
-
-  include Rainbows::Base
   autoload :ResponsePipe, 'rainbows/event_machine/response_pipe'
   autoload :ResponseChunkPipe, 'rainbows/event_machine/response_chunk_pipe'
   autoload :TryDefer, 'rainbows/event_machine/try_defer'
 
-  class Client < EM::Connection # :nodoc: all
-    attr_writer :body
-    include Rainbows::EvCore
-
-    def initialize(io)
-      @_io = io
-      @body = nil
-    end
-
-    alias write send_data
-
-    def receive_data(data)
-      # To avoid clobbering the current streaming response
-      # (often a static file), we do not attempt to process another
-      # request on the same connection until the first is complete
-      if @body
-        @buf << data
-        @_io.shutdown(Socket::SHUT_RD) if @buf.size > 0x1c000
-        EM.next_tick { receive_data('') }
-      else
-        on_read(data)
-      end
-    end
-
-    def quit
-      super
-      close_connection_after_writing
-    end
-
-    def app_call
-      set_comm_inactivity_timeout 0
-      @env[RACK_INPUT] = @input
-      @env[REMOTE_ADDR] = @_io.kgio_addr
-      @env[ASYNC_CALLBACK] = method(:em_write_response)
-      @env[ASYNC_CLOSE] = EM::DefaultDeferrable.new
-
-      response = catch(:async) { APP.call(@env.update(RACK_DEFAULTS)) }
-
-      # too tricky to support pipelining with :async since the
-      # second (pipelined) request could be a stuck behind a
-      # long-running async response
-      (response.nil? || -1 == response[0]) and return @state = :close
-
-      alive = @hp.keepalive? && G.alive && G.kato > 0
-      em_write_response(response, alive)
-      if alive
-        @hp.reset
-        @state = :headers
-        if @buf.empty?
-          set_comm_inactivity_timeout(G.kato)
-        else
-          EM.next_tick { receive_data('') }
-        end
-      end
-    end
-
-    def em_write_response(response, alive = false)
-      status, headers, body = response
-      if @hp.headers?
-        headers = HH.new(headers)
-        headers[CONNECTION] = alive ? KEEP_ALIVE : CLOSE
-      else
-        headers = nil
-      end
-
-      if body.respond_to?(:errback) && body.respond_to?(:callback)
-        @body = body
-        body.callback { quit }
-        body.errback { quit }
-        # async response, this could be a trickle as is in comet-style apps
-        headers[CONNECTION] = CLOSE if headers
-        alive = true
-      elsif body.respond_to?(:to_path)
-        st = File.stat(path = body.to_path)
-
-        if st.file?
-          write(response_header(status, headers)) if headers
-          @body = stream_file_data(path)
-          @body.errback do
-            body.close if body.respond_to?(:close)
-            quit
-          end
-          @body.callback do
-            body.close if body.respond_to?(:close)
-            @body = nil
-            alive ? receive_data('') : quit
-          end
-          return
-        elsif st.socket? || st.pipe?
-          @body = io = body_to_io(body)
-          chunk = stream_response_headers(status, headers) if headers
-          m = chunk ? ResponseChunkPipe : ResponsePipe
-          return EM.watch(io, m, self, alive, body).notify_readable = true
-        end
-        # char or block device... WTF? fall through to body.each
-      end
-
-      write(response_header(status, headers)) if headers
-      write_body_each(self, body)
-      quit unless alive
-    end
-
-    def unbind
-      async_close = @env[ASYNC_CLOSE] and async_close.succeed
-      @body.respond_to?(:fail) and @body.fail
-      begin
-        @_io.close
-      rescue Errno::EBADF
-        # EventMachine's EventableDescriptor::Close() may close
-        # the underlying file descriptor without invalidating the
-        # associated IO object on errors, so @_io.closed? isn't
-        # sufficient.
-      end
-    end
-  end
-
-  module Server # :nodoc: all
-    def close
-      detach
-      @io.close
-    end
-
-    def notify_readable
-      return if CUR.size >= MAX
-      io = @io.kgio_tryaccept or return
-      sig = EM.attach_fd(io.fileno, false)
-      CUR[sig] = CL.new(sig, io)
-    end
-  end
+  include Rainbows::Base
 
   def init_worker_process(worker) # :nodoc:
     Rainbows::Response.setup(Rainbows::EventMachine::Client)
@@ -189,20 +58,22 @@ module Rainbows::EventMachine
   def worker_loop(worker) # :nodoc:
     init_worker_process(worker)
     G.server.app.respond_to?(:deferred?) and
-      G.server.app = TryDefer[G.server.app]
+      G.server.app = Rainbows::EventMachine::TryDefer[G.server.app]
 
     # enable them both, should be non-fatal if not supported
     EM.epoll
     EM.kqueue
     logger.info "#@use: epoll=#{EM.epoll?} kqueue=#{EM.kqueue?}"
     client_class = Rainbows.const_get(@use).const_get(:Client)
-    Server.const_set(:MAX, worker_connections + LISTENERS.size)
-    Server.const_set(:CL, client_class)
+    max = worker_connections + LISTENERS.size
+    Rainbows::EventMachine::Server.const_set(:MAX, max)
+    Rainbows::EventMachine::Server.const_set(:CL, client_class)
     client_class.const_set(:APP, G.server.app)
+    Rainbows::EvCore.setup
     EM.run {
       conns = EM.instance_variable_get(:@conns) or
         raise RuntimeError, "EM @conns instance variable not accessible!"
-      Server.const_set(:CUR, conns)
+      Rainbows::EventMachine::Server.const_set(:CUR, conns)
       EM.add_periodic_timer(1) do
         unless G.tick
           conns.each_value { |c| client_class === c and c.quit }
@@ -210,8 +81,13 @@ module Rainbows::EventMachine
         end
       end
       LISTENERS.map! do |s|
-        EM.watch(s, Server) { |c| c.notify_readable = true }
+        EM.watch(s, Rainbows::EventMachine::Server) do |c|
+          c.notify_readable = true
+        end
       end
     }
   end
 end
+# :enddoc:
+require 'rainbows/event_machine/client'
+require 'rainbows/event_machine/server'

data/lib/rainbows/fiber/base.rb

@@ -18,11 +18,10 @@ module Rainbows::Fiber::Base
   # for one second (returned by the schedule_sleepers method) which
   # will cause it.
   def schedule(&block)
-    ret = begin
+    begin
       G.tick
-      RD.compact.each { |c| c.f.resume } # attempt to time out idle clients
       t = schedule_sleepers
-      Kernel.select(RD.compact.concat(LISTENERS), WR.compact, nil, t) or return
+      ret = select(RD.compact.concat(LISTENERS), WR.compact, nil, t)
     rescue Errno::EINTR
       retry
     rescue Errno::EBADF, TypeError
@@ -30,15 +29,15 @@ module Rainbows::Fiber::Base
       raise
     end or return
 
-    # active writers first, then _all_ readers for keepalive timeout
-    ret[1].concat(RD.compact).each { |c| c.f.resume }
+    # active writers first, then readers
+    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)
   end
 
-  # wakes up any sleepers that need to be woken and
-  # returns an interval to IO.select on
+  # wakes up any sleepers or keepalive-timeout violators that need to be
+  # woken and returns an interval to IO.select on
   def schedule_sleepers
     max = nil
     now = Time.now

data/lib/rainbows/fiber/body.rb

@@ -11,9 +11,9 @@ module Rainbows::Fiber::Body # :nodoc:
   }
 
   # the sendfile 1.0.0+ gem includes IO#sendfile_nonblock
-  if ::IO.method_defined?(:sendfile_nonblock)
+  if IO.method_defined?(:sendfile_nonblock)
     def write_body_file(client, body, range)
-      sock, n = client.to_io, nil
+      sock, n, body = client.to_io, nil, body_to_io(body)
       offset, count = range ? range : [ 0, body.stat.size ]
       begin
         offset += (n = sock.sendfile_nonblock(body, offset, count))
@@ -23,6 +23,8 @@ module Rainbows::Fiber::Body # :nodoc:
       rescue EOFError
         break
       end while (count -= n) > 0
+      ensure
+        close_if_private(body)
     end
   else
     ALIASES[:write_body] = :write_body_each

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

@@ -0,0 +1,15 @@
+# -*- encoding: binary -*-
+# :enddoc:
+class Rainbows::Fiber::Coolio::Heartbeat < Coolio::TimerWatcher
+  G = Rainbows::G
+
+  # ZZ gets populated by read_expire in rainbows/fiber/io/methods
+  ZZ = Rainbows::Fiber::ZZ
+  def on_timer
+    exit if (! G.tick && G.cur <= 0)
+    now = Time.now
+    fibs = []
+    ZZ.delete_if { |fib, time| now >= time ? fibs << fib : ! fib.alive? }
+    fibs.each { |fib| fib.resume if fib.alive? }
+  end
+end

data/lib/rainbows/fiber/{rev → coolio}/methods.rb

@@ -1,11 +1,11 @@
 # -*- encoding: binary -*-
 # :enddoc:
-module Rainbows::Fiber::Rev::Methods
-  class Watcher < Rev::IOWatcher
+module Rainbows::Fiber::Coolio::Methods
+  class Watcher < Coolio::IOWatcher
     def initialize(fio, flag)
       @f = Fiber.current
       super(fio, flag)
-      attach(Rev::Loop.default)
+      attach(Coolio::Loop.default)
     end
 
     def on_readable
@@ -31,7 +31,6 @@ module Rainbows::Fiber::Rev::Methods
   def kgio_wait_readable
     @r = Watcher.new(self, :r) unless defined?(@r)
     @r.enable unless @r.enabled?
-    KATO << Fiber.current
     Fiber.yield
     @r.disable
   end
@@ -44,5 +43,5 @@ end
   Rainbows::Fiber::IO::Socket,
   Rainbows::Fiber::IO::Pipe
 ].each do |klass|
-  klass.__send__(:include, Rainbows::Fiber::Rev::Methods)
+  klass.__send__(:include, Rainbows::Fiber::Coolio::Methods)
 end

data/lib/rainbows/fiber/{rev → coolio}/server.rb

@@ -1,6 +1,6 @@
 # -*- encoding: binary -*-
 # :enddoc:
-class Rainbows::Fiber::Rev::Server < Rev::IOWatcher
+class Rainbows::Fiber::Coolio::Server < Coolio::IOWatcher
   G = Rainbows::G
   include Rainbows::ProcessClient
 

data/lib/rainbows/fiber/{rev → coolio}/sleeper.rb

@@ -1,11 +1,11 @@
 # -*- encoding: binary -*-
 # :enddoc:
-class Rainbows::Fiber::Rev::Sleeper < Rev::TimerWatcher
+class Rainbows::Fiber::Coolio::Sleeper < Coolio::TimerWatcher
 
   def initialize(seconds)
     @f = Fiber.current
     super(seconds, false)
-    attach(Rev::Loop.default)
+    attach(Coolio::Loop.default)
     Fiber.yield
   end
 

data/lib/rainbows/fiber/coolio.rb

@@ -0,0 +1,12 @@
+# -*- encoding: binary -*-
+# :enddoc:
+require 'rainbows/coolio_support'
+require 'rainbows/fiber'
+require 'rainbows/fiber/io'
+
+module Rainbows::Fiber::Coolio
+  autoload :Heartbeat, 'rainbows/fiber/coolio/heartbeat'
+  autoload :Server, 'rainbows/fiber/coolio/server'
+  autoload :Sleeper, 'rainbows/fiber/coolio/sleeper'
+end
+require 'rainbows/fiber/coolio/methods'

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

@@ -8,8 +8,13 @@
 module Rainbows::Fiber::IO::Methods
   RD = Rainbows::Fiber::RD
   WR = Rainbows::Fiber::WR
+  ZZ = Rainbows::Fiber::ZZ
   attr_accessor :f
 
+  def read_expire
+    ZZ[Fiber.current] = super
+  end
+
   # for wrapping output response bodies
   def each(&block)
     if buf = kgio_read(16384)
@@ -30,6 +35,7 @@ module Rainbows::Fiber::IO::Methods
     @f = Fiber.current
     RD[fd] = self
     Fiber.yield
+    ZZ.delete @f
     RD[fd] = nil
   end