rainbows 2.1.0 → 3.0.0

data/lib/rainbows/coolio/core.rb

@@ -8,15 +8,12 @@ module Rainbows::Coolio::Core
   # given a INT, QUIT, or TERM signal)
   def worker_loop(worker)
     Rainbows::Response.setup(Rainbows::Coolio::Client)
-    require 'rainbows/coolio/sendfile'
-    Rainbows::Coolio::Client.__send__(:include, Rainbows::Coolio::Sendfile)
     init_worker_process(worker)
     mod = Rainbows.const_get(@use)
     rloop = Rainbows::Coolio::Server.const_set(:LOOP, Coolio::Loop.default)
-    Rainbows::Coolio::Client.const_set(:LOOP, rloop)
     Rainbows::Coolio::Server.const_set(:MAX, @worker_connections)
     Rainbows::Coolio::Server.const_set(:CL, mod.const_get(:Client))
-    Rainbows::EvCore.const_set(:APP, G.server.app)
+    Rainbows::EvCore.const_set(:APP, Rainbows.server.app)
     Rainbows::EvCore.setup
     Rainbows::Coolio::Heartbeat.new(1, true).attach(rloop)
     LISTENERS.map! { |s| Rainbows::Coolio::Server.new(s).attach(rloop) }

data/lib/rainbows/coolio/heartbeat.rb

@@ -8,13 +8,12 @@
 class Rainbows::Coolio::Heartbeat < Coolio::TimerWatcher
   KATO = Rainbows::Coolio::KATO
   CONN = Rainbows::Coolio::CONN
-  G = Rainbows::G
 
   def on_timer
-    if (ot = G.kato) >= 0
+    if (ot = Rainbows.keepalive_timeout) >= 0
       ot = Time.now - ot
       KATO.delete_if { |client, time| time < ot and client.timeout? }
     end
-    exit if (! G.tick && CONN.size <= 0)
+    exit if (! Rainbows.tick && CONN.size <= 0)
   end
 end

data/lib/rainbows/coolio/master.rb

@@ -7,15 +7,16 @@ class Rainbows::Coolio::Master < Coolio::IOWatcher
     @reader, @writer = Kgio::Pipe.new
     super(@reader)
     @queue = queue
+    @wbuf, @rbuf = "\0", "\0"
   end
 
   def <<(output)
     @queue << output
-    @writer.kgio_trywrite("\0")
+    @writer.kgio_trywrite(@wbuf)
   end
 
   def on_readable
-    if String === @reader.kgio_tryread(1)
+    if String === @reader.kgio_tryread(1, @rbuf)
       client, response = @queue.pop
       client.response_write(response)
     end

data/lib/rainbows/coolio/{deferred_chunk_response.rb → response_chunk_pipe.rb}

@@ -2,8 +2,7 @@
 # :enddoc:
 #
 # this is class is specific to Coolio for proxying IO-derived objects
-class Rainbows::Coolio::DeferredChunkResponse <
-      Rainbows::Coolio::DeferredResponse
+class Rainbows::Coolio::ResponseChunkPipe < Rainbows::Coolio::ResponsePipe
   def on_read(data)
     @client.write("#{data.size.to_s(16)}\r\n")
     @client.write(data)

data/lib/rainbows/coolio/{deferred_response.rb → response_pipe.rb}

@@ -3,7 +3,7 @@
 #
 # this is class is specific to Coolio for writing large static files
 # or proxying IO-derived objects
-class Rainbows::Coolio::DeferredResponse < Coolio::IO
+class Rainbows::Coolio::ResponsePipe < Coolio::IO
   def initialize(io, client, body)
     super(io)
     @client, @body = client, body

data/lib/rainbows/coolio/thread_client.rb

@@ -14,11 +14,9 @@ class Rainbows::Coolio::ThreadClient < Rainbows::Coolio::Client
 
   # this is only called in the master thread
   def response_write(response)
-    alive = @hp.next? && G.alive
-    coolio_write_response(response, alive)
-    return quit unless alive && :close != @state
-
-    @state = :headers
+    ev_write_response(*response, @hp.next?)
+    rescue => e
+      handle_error(e)
   end
 
   # fails-safe application dispatch, we absolutely cannot
@@ -27,7 +25,7 @@ class Rainbows::Coolio::ThreadClient < Rainbows::Coolio::Client
   def app_response
     begin
       @env[REMOTE_ADDR] = @_io.kgio_addr
-      APP.call(@env.update(RACK_DEFAULTS))
+      APP.call(@env.merge!(RACK_DEFAULTS))
     rescue => e
       Rainbows::Error.app(e) # we guarantee this does not raise
       [ 500, {}, [] ]

data/lib/rainbows/coolio_fiber_spawn.rb

@@ -18,7 +18,7 @@ module Rainbows::CoolioFiberSpawn
     init_worker_process(worker)
     Server.const_set(:MAX, @worker_connections)
     Rainbows::Fiber::Base.setup(Server, nil)
-    Server.const_set(:APP, G.server.app)
+    Server.const_set(:APP, Rainbows.server.app)
     Heartbeat.new(1, true).attach(Coolio::Loop.default)
     LISTENERS.map! { |s| Server.new(s).attach(Coolio::Loop.default) }
     Coolio::Loop.default.run

data/lib/rainbows/coolio_thread_pool.rb

@@ -16,6 +16,7 @@
 # users are NOT advised to use this due to high CPU usage.
 module Rainbows::CoolioThreadPool
   # :stopdoc:
+  autoload :Client, 'rainbows/coolio_thread_pool/client'
   DEFAULTS = {
     :pool_size => 20, # same default size as ThreadPool (w/o Coolio)
   }
@@ -53,5 +54,4 @@ module Rainbows::CoolioThreadPool
   end
 end
 # :enddoc:
-require 'rainbows/coolio_thread_pool/client'
 require 'rainbows/coolio_thread_pool/watcher'

data/lib/rainbows/coolio_thread_pool/watcher.rb

@@ -1,14 +1,12 @@
 # -*- encoding: binary -*-
 # :enddoc:
 class Rainbows::CoolioThreadPool::Watcher < Coolio::TimerWatcher
-  G = Rainbows::G
-
   def initialize(threads)
     @threads = threads
-    super(G.server.timeout, true)
+    super(Rainbows.server.timeout, true)
   end
 
   def on_timer
-    @threads.each { |t| t.join(0) and G.quit! }
+    @threads.each { |t| t.join(0) and Rainbows.quit! }
   end
 end

data/lib/rainbows/coolio_thread_spawn.rb

@@ -15,6 +15,7 @@
 # users are NOT advised to use this due to high CPU usage.
 module Rainbows::CoolioThreadSpawn
   include Rainbows::Coolio::Core
+  autoload :Client, 'rainbows/coolio_thread_spawn/client'
 
   def init_worker_process(worker) # :nodoc:
     super
@@ -24,4 +25,3 @@ module Rainbows::CoolioThreadSpawn
   end
 end
 # :enddoc:
-require 'rainbows/coolio_thread_spawn/client'

data/lib/rainbows/dev_fd_response.rb

@@ -39,7 +39,7 @@ class Rainbows::DevFdResponse < Struct.new(:app)
     io ||= File.open(body.to_path) if body.respond_to?(:to_path)
     return response if io.nil?
 
-    headers = HeaderHash.new(headers)
+    headers = Rack::Utils::HeaderHash.new(headers) unless Hash === headers
     st = io.stat
     fileno = io.fileno
     FD_MAP[fileno] = io
@@ -47,7 +47,7 @@ class Rainbows::DevFdResponse < Struct.new(:app)
       headers['Content-Length'] ||= st.size.to_s
       headers.delete('Transfer-Encoding')
     elsif st.pipe? || st.socket? # epoll-able things
-      unless headers['Content-Length']
+      unless headers.include?('Content-Length')
         if env['rainbows.autochunk']
           headers['Transfer-Encoding'] = 'chunked'
         else

data/lib/rainbows/error.rb

@@ -2,8 +2,6 @@
 # :enddoc:
 module Rainbows::Error
 
-  G = Rainbows::G
-
   # if we get any error, try to write something back to the client
   # assuming we haven't closed the socket, but don't get hung up
   # if the socket is already closed or broken.  We'll always ensure
@@ -20,15 +18,15 @@ module Rainbows::Error
   end
 
   def self.app(e)
-    G.server.logger.error "app error: #{e.inspect}"
-    G.server.logger.error e.backtrace.join("\n")
+    Rainbows.server.logger.error "app error: #{e.inspect}"
+    Rainbows.server.logger.error e.backtrace.join("\n")
     rescue
   end
 
   def self.listen_loop(e)
-    G.alive or return
-    G.server.logger.error "listen loop error: #{e.inspect}."
-    G.server.logger.error e.backtrace.join("\n")
+    Rainbows.alive or return
+    Rainbows.server.logger.error "listen loop error: #{e.inspect}."
+    Rainbows.server.logger.error e.backtrace.join("\n")
     rescue
   end
 

data/lib/rainbows/ev_core.rb

@@ -4,16 +4,28 @@
 module Rainbows::EvCore
   include Rainbows::Const
   include Rainbows::Response
-  G = Rainbows::G
   NULL_IO = Unicorn::HttpRequest::NULL_IO
-  HttpParser = Unicorn::HttpParser
+  HttpParser = Rainbows::HttpParser
   autoload :CapInput, 'rainbows/ev_core/cap_input'
 
   # 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
+    if alive = @hp.next?
+      # we can't do HTTP keepalive without Content-Length or
+      # "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])
+    end
+    @deferred = nil
+    ev_write_response(status, headers, body, alive)
+  end
+
   def post_init
     @hp = HttpParser.new
     @env = @hp.env
@@ -36,14 +48,15 @@ module Rainbows::EvCore
   end
 
   # returns whether to enable response chunking for autochunk models
-  def stream_response_headers(status, headers)
-    if headers['Content-Length']
+  def stream_response_headers(status, headers, alive)
+    headers = Rack::Utils::HeaderHash.new(headers) unless Hash === headers
+    if headers.include?(Content_Length)
       rv = false
     else
-      rv = !!(headers['Transfer-Encoding'] =~ %r{\Achunked\z}i)
+      rv = !!(headers[Transfer_Encoding] =~ %r{\Achunked\z}i)
       rv = false if headers.delete('X-Rainbows-Autochunk') == 'no'
     end
-    write(response_header(status, headers))
+    write_headers(status, headers, alive)
     rv
   end
 

data/lib/rainbows/event_machine.rb

@@ -44,6 +44,7 @@ module Rainbows::EventMachine
   autoload :ResponsePipe, 'rainbows/event_machine/response_pipe'
   autoload :ResponseChunkPipe, 'rainbows/event_machine/response_chunk_pipe'
   autoload :TryDefer, 'rainbows/event_machine/try_defer'
+  autoload :Client, 'rainbows/event_machine/client'
 
   include Rainbows::Base
 
@@ -57,8 +58,9 @@ module Rainbows::EventMachine
   # given a INT, QUIT, or TERM signal)
   def worker_loop(worker) # :nodoc:
     init_worker_process(worker)
-    G.server.app.respond_to?(:deferred?) and
-      G.server.app = Rainbows::EventMachine::TryDefer[G.server.app]
+    server = Rainbows.server
+    server.app.respond_to?(:deferred?) and
+      server.app = TryDefer.new(server.app)
 
     # enable them both, should be non-fatal if not supported
     EM.epoll
@@ -68,14 +70,14 @@ module Rainbows::EventMachine
     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)
+    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!"
       Rainbows::EventMachine::Server.const_set(:CUR, conns)
       EM.add_periodic_timer(1) do
-        unless G.tick
+        unless Rainbows.tick
           conns.each_value { |c| client_class === c and c.quit }
           EM.stop if conns.empty? && EM.reactor_running?
         end
@@ -89,5 +91,4 @@ module Rainbows::EventMachine
   end
 end
 # :enddoc:
-require 'rainbows/event_machine/client'
 require 'rainbows/event_machine/server'

data/lib/rainbows/event_machine/client.rb

@@ -1,12 +1,11 @@
 # -*- encoding: binary -*-
 # :enddoc:
 class Rainbows::EventMachine::Client < EM::Connection
-  attr_writer :body
   include Rainbows::EvCore
 
   def initialize(io)
     @_io = io
-    @body = nil
+    @deferred = nil
   end
 
   alias write send_data
@@ -15,7 +14,7 @@ class Rainbows::EventMachine::Client < EM::Connection
     # 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 @deferred
       if data
         @buf << data
         @_io.shutdown(Socket::SHUT_RD) if @buf.size > 0x1c000
@@ -35,83 +34,77 @@ class Rainbows::EventMachine::Client < EM::Connection
     set_comm_inactivity_timeout 0
     @env[RACK_INPUT] = @input
     @env[REMOTE_ADDR] = @_io.kgio_addr
-    @env[ASYNC_CALLBACK] = method(:em_write_response)
+    @env[ASYNC_CALLBACK] = method(:write_async_response)
     @env[ASYNC_CLOSE] = EM::DefaultDeferrable.new
+    status, headers, body = catch(:async) {
+      APP.call(@env.merge!(RACK_DEFAULTS))
+    }
 
-    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
+    (nil == status || -1 == status) ? @deferred = true :
+      ev_write_response(status, headers, body, @hp.next?)
+  end
 
-    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)
+  def deferred_errback(orig_body)
+    @deferred.errback do
+      orig_body.close if orig_body.respond_to?(:close)
+      quit
     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
+  def deferred_callback(orig_body, alive)
+    @deferred.callback do
+      orig_body.close if orig_body.respond_to?(:close)
+      @deferred = nil
+      alive ? receive_data(nil) : quit
     end
+  end
 
+  def ev_write_response(status, headers, body, alive)
+    @state = :headers if alive
     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
+      @deferred = body
+      deferred_errback(body)
+      deferred_callback(body, alive)
     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
+        write_headers(status, headers, alive)
+        @deferred = stream_file_data(path)
+        deferred_errback(body)
+        deferred_callback(body, alive)
         return
       elsif st.socket? || st.pipe?
-        @body = io = body_to_io(body)
-        chunk = stream_response_headers(status, headers) if headers
+        io = body_to_io(@deferred = body)
+        chunk = stream_response_headers(status, headers, alive)
         m = chunk ? Rainbows::EventMachine::ResponseChunkPipe :
                     Rainbows::EventMachine::ResponsePipe
-        return EM.watch(io, m, self, alive, body).notify_readable = true
+        return EM.watch(io, m, self).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
+    write_response(status, headers, body, alive)
+    if alive
+      if @deferred.nil?
+        if @buf.empty?
+          set_comm_inactivity_timeout(Rainbows.keepalive_timeout)
+        else
+          EM.next_tick { receive_data(nil) }
+        end
+      end
+    else
+      quit unless @deferred
+    end
   end
 
   def next!
-    @hp.keepalive? ? receive_data(@body = nil) : quit
+    @deferred.close if @deferred.respond_to?(:close)
+    @hp.keepalive? ? receive_data(@deferred = nil) : quit
   end
 
   def unbind
     async_close = @env[ASYNC_CLOSE] and async_close.succeed
-    @body.respond_to?(:fail) and @body.fail
+    @deferred.respond_to?(:fail) and @deferred.fail
     begin
       @_io.close
     rescue Errno::EBADF