rainbows 0.94.0 → 0.95.0

data/lib/rainbows/event_machine.rb

@@ -48,8 +48,9 @@ module Rainbows
 
     include Base
 
-    class Client < EM::Connection
+    class Client < EM::Connection # :nodoc: all
       include Rainbows::EvCore
+      include Rainbows::Response
       G = Rainbows::G
 
       def initialize(io)
@@ -70,7 +71,7 @@ module Rainbows
         begin
           @env[RACK_INPUT] = @input
           @env[REMOTE_ADDR] = @remote_addr
-          @env[ASYNC_CALLBACK] = method(:response_write)
+          @env[ASYNC_CALLBACK] = method(:em_write_response)
 
           # we're not sure if anybody uses this, but Thin sets it, too
           @env[ASYNC_CLOSE] = EM::DefaultDeferrable.new
@@ -80,11 +81,11 @@ module Rainbows
           # 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.first) and return @state = :close
+          (response.nil? || -1 == response[0]) and return @state = :close
 
           alive = @hp.keepalive? && G.alive
           out = [ alive ? CONN_ALIVE : CONN_CLOSE ] if @hp.headers?
-          response_write(response, out, alive)
+          em_write_response(response, out, alive)
 
           if alive
             @env.clear
@@ -98,32 +99,29 @@ module Rainbows
         end while true
       end
 
-      def response_write(response, out = [ CONN_CLOSE ], alive = false)
-        @body = body = response.last
+      def em_write_response(response, out = [ CONN_CLOSE ], alive = false)
+        @body = body = response[2]
         if body.respond_to?(:errback) && body.respond_to?(:callback)
           body.callback { quit }
           body.errback { quit }
-          HttpResponse.write(self, response, out)
+          write_header(self, response, out)
+          write_body_each(self, body)
           return
         elsif ! body.respond_to?(:to_path)
-          HttpResponse.write(self, response, out)
+          write_response(self, response, out)
           quit unless alive
           return
         end
 
         headers = Rack::Utils::HeaderHash.new(response[1])
-        path = body.to_path
-        io = body.to_io if body.respond_to?(:to_io)
-        io ||= IO.new($1.to_i) if path =~ %r{\A/dev/fd/(\d+)\z}
-        io ||= File.open(path, 'rb') # could be a named pipe
-
+        io = body_to_io(body)
         st = io.stat
+
         if st.file?
           headers.delete('Transfer-Encoding')
           headers['Content-Length'] ||= st.size.to_s
-          response = [ response.first, headers.to_hash, [] ]
-          HttpResponse.write(self, response, out)
-          stream = stream_file_data(path)
+          write_header(self, [ response[0], headers ], out)
+          stream = stream_file_data(body.to_path)
           stream.callback { quit } unless alive
         elsif st.socket? || st.pipe?
           do_chunk = !!(headers['Transfer-Encoding'] =~ %r{\Achunked\z}i)
@@ -133,15 +131,14 @@ module Rainbows
           else
             out[0] = CONN_CLOSE
           end
-          response = [ response.first, headers.to_hash, [] ]
-          HttpResponse.write(self, response, out)
+          write_header(self, [ response[0], headers ], out)
           if do_chunk
             EM.watch(io, ResponseChunkPipe, self).notify_readable = true
           else
             EM.enable_proxy(EM.attach(io, ResponsePipe, self), self, 16384)
           end
         else
-          HttpResponse.write(self, response, out)
+          write_response(self, response, out)
         end
       end
 
@@ -152,7 +149,7 @@ module Rainbows
       end
     end
 
-    module ResponsePipe
+    module ResponsePipe # :nodoc: all
       def initialize(client)
         @client = client
       end
@@ -163,7 +160,7 @@ module Rainbows
       end
     end
 
-    module ResponseChunkPipe
+    module ResponseChunkPipe # :nodoc: all
       include ResponsePipe
 
       def unbind
@@ -190,7 +187,7 @@ module Rainbows
       end
     end
 
-    module Server
+    module Server # :nodoc: all
 
       def close
         detach
@@ -208,7 +205,7 @@ module Rainbows
     # Middleware that will run the app dispatch in a separate thread.
     # This middleware is automatically loaded by Rainbows! when using
     # EventMachine and if the app responds to the +deferred?+ method.
-    class TryDefer < Struct.new(:app)
+    class TryDefer < Struct.new(:app) # :nodoc: all
 
       def initialize(app)
         # the entire app becomes multithreaded, even the root (non-deferred)
@@ -229,10 +226,15 @@ module Rainbows
       end
     end
 
+    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)
-    def worker_loop(worker)
+    def worker_loop(worker) # :nodoc:
       init_worker_process(worker)
       G.server.app.respond_to?(:deferred?) and
         G.server.app = TryDefer[G.server.app]

data/lib/rainbows/fiber/base.rb

@@ -1,14 +1,15 @@
 # -*- encoding: binary -*-
+# :enddoc:
 require 'rainbows/fiber/io'
 
 module Rainbows
   module Fiber
 
-    # blocked readers (key: Rainbows::Fiber::IO object, value is irrelevant)
-    RD = {}.compare_by_identity
+    # blocked readers (key: fileno, value: Rainbows::Fiber::IO object)
+    RD = []
 
-    # blocked writers (key: Rainbows::Fiber::IO object, value is irrelevant)
-    WR = {}.compare_by_identity
+    # blocked writers (key: fileno, value: Rainbows::Fiber::IO object)
+    WR = []
 
     # sleeping fibers go here (key: Fiber object, value: wakeup time)
     ZZ = {}.compare_by_identity
@@ -35,9 +36,10 @@ module Rainbows
       def schedule(&block)
         ret = begin
           G.tick
-          RD.keys.each { |c| c.f.resume } # attempt to time out idle clients
+          RD.compact.each { |c| c.f.resume } # attempt to time out idle clients
           t = schedule_sleepers
-          Kernel.select(RD.keys.concat(LISTENERS), WR.keys, nil, t) or return
+          Kernel.select(RD.compact.concat(LISTENERS),
+                        WR.compact, nil, t) or return
         rescue Errno::EINTR
           retry
         rescue Errno::EBADF, TypeError
@@ -46,10 +48,10 @@ module Rainbows
         end or return
 
         # active writers first, then _all_ readers for keepalive timeout
-        ret[1].concat(RD.keys).each { |c| c.f.resume }
+        ret[1].concat(RD.compact).each { |c| c.f.resume }
 
         # accept is an expensive syscall, filter out listeners we don't want
-        (ret.first & LISTENERS).each(&block)
+        (ret[0] & LISTENERS).each(&block)
       end
 
       # wakes up any sleepers that need to be woken and
@@ -61,54 +63,42 @@ module Rainbows
         ZZ.delete_if { |fib, time|
           if now >= time
             fibs << fib
-            now = Time.now
           else
             max = time
             false
           end
         }
         fibs.each { |fib| fib.resume }
+        now = Time.now
         max.nil? || max > (now + 1) ? 1 : max - now
       end
 
-      def process_client(client)
-        G.cur += 1
+      def wait_headers_readable(client)
         io = client.to_io
-        buf = client.read_timeout or return
-        hp = HttpParser.new
-        env = {}
-        alive = true
-        remote_addr = Rainbows.addr(io)
-
-        begin # loop
-          while ! hp.headers(env, buf)
-            buf << (client.read_timeout or return)
-          end
-
-          env[CLIENT_IO] = client
-          env[RACK_INPUT] = 0 == hp.content_length ?
-                    HttpRequest::NULL_IO : TeeInput.new(client, env, hp, buf)
-          env[REMOTE_ADDR] = remote_addr
-          response = APP.call(env.update(RACK_DEFAULTS))
-
-          if 100 == response.first.to_i
-            client.write(EXPECT_100_RESPONSE)
-            env.delete(HTTP_EXPECT)
-            response = APP.call(env)
-          end
+        expire = nil
+        begin
+          return io.recv_nonblock(1, Socket::MSG_PEEK)
+        rescue Errno::EAGAIN
+          return if expire && expire < Time.now
+          expire ||= Time.now + G.kato
+          client.wait_readable
+          retry
+        end
+      end
 
-          alive = hp.keepalive? && G.alive
-          out = [ alive ? CONN_ALIVE : CONN_CLOSE ] if hp.headers?
-          HttpResponse.write(client, response, out)
-        end while alive and hp.reset.nil? and env.clear
-      rescue => e
-        Error.write(io, e)
+      def process_client(client)
+        G.cur += 1
+        super(client) # see Rainbows::Base
       ensure
         G.cur -= 1
         ZZ.delete(client.f)
-        client.close
       end
 
+      def self.setup(klass, app)
+        require 'rainbows/fiber/body'
+        klass.__send__(:include, Rainbows::Fiber::Body)
+        self.const_set(:APP, app)
+      end
     end
   end
 end

data/lib/rainbows/fiber/body.rb

@@ -0,0 +1,34 @@
+# -*- encoding: binary -*-
+# :enddoc:
+# non-portable body handling for Fiber-based concurrency goes here
+# this module is required and included in worker processes only
+# this is meant to be included _after_ Rainbows::Response::Body
+module Rainbows::Fiber::Body # :nodoc:
+
+  # TODO non-blocking splice(2) under Linux
+  ALIASES = {
+    :write_body_stream => :write_body_each
+  }
+
+  # the sendfile 1.0.0+ gem includes IO#sendfile_nonblock
+  if ::IO.method_defined?(:sendfile_nonblock)
+    def write_body_file(client, body)
+      sock, off = client.to_io, 0
+      begin
+        off += sock.sendfile_nonblock(body, off, 0x10000)
+      rescue Errno::EAGAIN
+        client.wait_writable
+      rescue EOFError
+        break
+      end while true
+    end
+  else
+    ALIASES[:write_body] = :write_body_each
+  end
+
+  def self.included(klass)
+    ALIASES.each do |new_method, orig_method|
+      klass.__send__(:alias_method, new_method, orig_method)
+    end
+  end
+end

data/lib/rainbows/fiber/io.rb

@@ -7,6 +7,20 @@ module Rainbows
     # interface that yields away from the current Fiber whenever
     # the underlying IO object cannot read or write
     class IO < Struct.new(:to_io, :f)
+      include Rainbows::ByteSlice
+
+      # :stopdoc:
+      LOCALHOST = Unicorn::HttpRequest::LOCALHOST
+
+      # needed to write errors with
+      def write_nonblock(buf)
+        to_io.write_nonblock(buf)
+      end
+
+      # enough for Rainbows.addr
+      def peeraddr
+        to_io.respond_to?(:peeraddr) ? to_io.peeraddr : [ LOCALHOST ]
+      end
 
       # for wrapping output response bodies
       def each(&block)
@@ -19,27 +33,33 @@ module Rainbows
       end
 
       def close
-        RD.delete(self)
-        WR.delete(self)
+        fileno = to_io.fileno
+        RD[fileno] = WR[fileno] = nil
         to_io.close unless to_io.closed?
       end
 
+      def closed?
+        to_io.closed?
+      end
+
       def wait_readable
-        RD[self] = false
+        fileno = to_io.fileno
+        RD[fileno] = self
         ::Fiber.yield
-        RD.delete(self)
+        RD[fileno] = nil
       end
 
       def wait_writable
-        WR[self] = false
+        fileno = to_io.fileno
+        WR[fileno] = self
         ::Fiber.yield
-        WR.delete(self)
+        WR[fileno] = nil
       end
 
       def write(buf)
         begin
-          (w = to_io.write_nonblock(buf)) == buf.size and return
-          buf = buf[w..-1]
+          (w = to_io.write_nonblock(buf)) == buf.bytesize and return
+          buf = byte_slice(buf, w..-1)
         rescue Errno::EAGAIN
           wait_writable
           retry

data/lib/rainbows/fiber/queue.rb

@@ -1,4 +1,5 @@
 # -*- encoding: binary -*-
+# :enddoc:
 module Rainbows
   module Fiber
 

data/lib/rainbows/fiber/rev.rb

@@ -1,4 +1,5 @@
 # -*- encoding: binary -*-
+# :enddoc:
 require 'rev'
 require 'rainbows/fiber'
 require 'rainbows/fiber/io'
@@ -52,6 +53,7 @@ module Rainbows::Fiber
       include Unicorn
       include Rainbows
       include Rainbows::Const
+      include Rainbows::Response
       FIO = Rainbows::Fiber::IO
 
       def to_io
@@ -91,7 +93,7 @@ module Rainbows::Fiber
           env[REMOTE_ADDR] = remote_addr
           response = APP.call(env.update(RACK_DEFAULTS))
 
-          if 100 == response.first.to_i
+          if 100 == response[0].to_i
             client.write(EXPECT_100_RESPONSE)
             env.delete(HTTP_EXPECT)
             response = APP.call(env)
@@ -99,7 +101,7 @@ module Rainbows::Fiber
 
           alive = hp.keepalive? && G.alive
           out = [ alive ? CONN_ALIVE : CONN_CLOSE ] if hp.headers?
-          HttpResponse.write(client, response, out)
+          write_response(client, response, out)
         end while alive and hp.reset.nil? and env.clear
       rescue => e
         Error.write(io, e)

data/lib/rainbows/fiber.rb

@@ -1,4 +1,5 @@
 # -*- encoding: binary -*-
+# :enddoc:
 begin
   require 'fiber'
 rescue LoadError

data/lib/rainbows/fiber_pool.rb

@@ -16,7 +16,7 @@ module Rainbows
   module FiberPool
     include Fiber::Base
 
-    def worker_loop(worker)
+    def worker_loop(worker) # :nodoc:
       init_worker_process(worker)
       pool = []
       worker_connections.times {
@@ -24,7 +24,7 @@ module Rainbows
           process_client(::Fiber.yield) while pool << ::Fiber.current
         }.resume # resume to hit ::Fiber.yield so it waits on a client
       }
-      Fiber::Base.const_set(:APP, app)
+      Fiber::Base.setup(self.class, app)
 
       begin
         schedule do |l|

data/lib/rainbows/fiber_spawn.rb

@@ -13,9 +13,9 @@ module Rainbows
   module FiberSpawn
     include Fiber::Base
 
-    def worker_loop(worker)
+    def worker_loop(worker) # :nodoc:
       init_worker_process(worker)
-      Fiber::Base.const_set(:APP, app)
+      Fiber::Base.setup(self.class, app)
       limit = worker_connections
       fio = Rainbows::Fiber::IO
 

data/lib/rainbows/http_response.rb

@@ -1,38 +1,27 @@
 # -*- encoding: binary -*-
-require 'time'
-
-module Rainbows
-
-  class HttpResponse < ::Unicorn::HttpResponse
-
-    def self.header_string(status, headers, out)
-      status = CODES[status.to_i] || status
+# :enddoc:
+# deprecated, use Rainbows::Response instead
+# Cramp 0.11 relies on this, and is only activated by Cramp
+if defined?(Cramp) && defined?(Rainbows::EventMachine::Client)
+  class Rainbows::HttpResponse
+    class << self
+      include Rainbows::Response
+      alias write write_response
+    end
+  end
 
-      headers.each do |key, value|
-        next if %r{\AX-Rainbows-}i =~ key
-        next if SKIP.include?(key.downcase)
-        if value =~ /\n/
-          # avoiding blank, key-only cookies with /\n+/
-          out.concat(value.split(/\n+/).map! { |v| "#{key}: #{v}\r\n" })
-        else
-          out << "#{key}: #{value}\r\n"
-        end
+  module Rainbows::EventMachine::CrampSocket
+    def write_header(_, response, out)
+      if websocket?
+        write web_socket_upgrade_data
+        web_socket_handshake!
+        out = nil # disable response headers
       end
-
-      "HTTP/1.1 #{status}\r\n" \
-      "Date: #{Time.now.httpdate}\r\n" \
-      "Status: #{status}\r\n" \
-      "#{out.join('')}\r\n"
+      super(self, response, out)
     end
+  end
 
-    def self.write(socket, rack_response, out = [])
-      status, headers, body = rack_response
-      out.instance_of?(Array) and
-        socket.write(header_string(status, headers, out))
-
-      body.each { |chunk| socket.write(chunk) }
-      ensure
-        body.respond_to?(:close) and body.close
-    end
+  class Rainbows::EventMachine::Client
+    include Rainbows::EventMachine::CrampSocket
   end
 end

data/lib/rainbows/http_server.rb

@@ -1,4 +1,5 @@
 # -*- encoding: binary -*-
+# :enddoc:
 module Rainbows
 
   class HttpServer < ::Unicorn::HttpServer
@@ -33,10 +34,8 @@ module Rainbows
     # connection we accept without wasting cycles.  That added to the
     # fact that we let clients keep idle connections open for long
     # periods of time means we have to chmod at a fixed interval.
-    alias_method :set_timeout, :timeout=
-    undef_method :timeout=
     def timeout=(nr)
-      set_timeout(nr + 1)
+      super(nr + 1)
     end
     #:startdoc:
 
@@ -70,7 +69,7 @@ module Rainbows
 
     def worker_connections(*args)
       return @worker_connections if args.empty?
-      nr = args.first
+      nr = args[0]
       (Integer === nr && nr > 0) or
         raise ArgumentError, "worker_connections must be a positive Integer"
       @worker_connections = nr

data/lib/rainbows/max_body.rb

@@ -1,4 +1,5 @@
 # -*- encoding: binary -*-
+# :enddoc:
 module Rainbows
 
 # middleware used to enforce client_max_body_size for TeeInput users,

data/lib/rainbows/never_block/event_machine.rb

@@ -1,3 +1,5 @@
+# -*- encoding: binary -*-
+# :enddoc:
 module Rainbows
   module NeverBlock
     class Client < Rainbows::EventMachine::Client

data/lib/rainbows/never_block.rb

@@ -18,13 +18,14 @@ module Rainbows
   #
   module NeverBlock
 
+    # :stopdoc:
     DEFAULTS = {
       :pool_size => 20, # same default size used by NB
       :backend => :EventMachine, # NeverBlock doesn't support Rev yet
     }
 
     # same pool size NB core itself uses
-    def self.setup
+    def self.setup # :nodoc:
       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"
@@ -34,7 +35,7 @@ module Rainbows
       G.server.extend(Core)
     end
 
-    module Core
+    module Core  # :nodoc: all
       def self.setup
         self.const_set(:POOL, ::NB::Pool::FiberPool.new(O[:pool_size]))
         base = O[:backend].to_s.gsub!(/([a-z])([A-Z])/, '\1_\2').downcase!
@@ -57,9 +58,7 @@ module Rainbows
           end
         end
       end
-    end
 
-    module Core
       def init_worker_process(worker)
         super
         Core.setup
@@ -67,5 +66,7 @@ module Rainbows
       end
     end
 
+    # :startdoc:
+
   end
 end

data/lib/rainbows/queue_pool.rb

@@ -1,4 +1,5 @@
 # -*- encoding: binary -*-
+# :enddoc:
 require 'thread'
 
 module Rainbows