rainbows 0.94.0 → 0.95.0

data/lib/rainbows/response/body.rb

@@ -0,0 +1,119 @@
+# -*- encoding: binary -*-
+# :enddoc:
+# non-portable body response stuff goes here
+#
+# The sendfile 1.0.0 RubyGem includes IO#sendfile and
+# IO#sendfile_nonblock.   Previous versions of "sendfile" didn't have
+# IO#sendfile_nonblock, and IO#sendfile in previous versions could
+# block other threads under 1.8 with large files
+#
+# IO#sendfile currently (June 2010) beats 1.9 IO.copy_stream with
+# non-Linux support and large files on 32-bit.  We still fall back to
+# IO.copy_stream (if available) if we're dealing with DevFdResponse
+# objects, though.
+#
+# Linux-only splice(2) support via the "io_splice" gem will eventually
+# be added for streaming sockets/pipes, too.
+#
+# * write_body_file - regular files (sendfile or pread+write)
+# * write_body_stream - socket/pipes (read+write, splice later)
+# * write_body_each - generic fallback
+#
+# callgraph is as follows:
+#
+#         write_body
+#         `- write_body_each
+#         `- write_body_path
+#            `- write_body_file
+#            `- write_body_stream
+#
+module Rainbows::Response::Body # :nodoc:
+  ALIASES = {}
+
+  # to_io is not part of the Rack spec, but make an exception here
+  # since we can conserve path lookups and file descriptors.
+  # \Rainbows! will never get here without checking for the existence
+  # of body.to_path first.
+  def body_to_io(body)
+    if body.respond_to?(:to_io)
+      body.to_io
+    else
+      # try to take advantage of Rainbows::DevFdResponse, calling File.open
+      # is a last resort
+      path = body.to_path
+      path =~ %r{\A/dev/fd/(\d+)\z} ? IO.new($1.to_i) : File.open(path, 'rb')
+    end
+  end
+
+  if IO.method_defined?(:sendfile_nonblock)
+    def write_body_file(sock, body)
+      sock.sendfile(body, 0)
+    end
+  end
+
+  if IO.respond_to?(:copy_stream)
+    unless method_defined?(:write_body_file)
+      # try to use sendfile() via IO.copy_stream, otherwise pread()+write()
+      def write_body_file(sock, body)
+        IO.copy_stream(body, sock, nil, 0)
+      end
+    end
+
+    # only used when body is a pipe or socket that can't handle
+    # pread() semantics
+    def write_body_stream(sock, body)
+      IO.copy_stream(body, sock)
+      ensure
+        body.respond_to?(:close) and body.close
+    end
+  else
+    # fall back to body#each, which is a Rack standard
+    ALIASES[:write_body_stream] = :write_body_each
+  end
+
+  if method_defined?(:write_body_file)
+
+    # middlewares/apps may return with a body that responds to +to_path+
+    def write_body_path(sock, body)
+      inp = body_to_io(body)
+      if inp.stat.file?
+        begin
+          write_body_file(sock, inp)
+        ensure
+          inp.close if inp != body
+        end
+      else
+        write_body_stream(sock, inp)
+      end
+      ensure
+        body.respond_to?(:close) && inp != body and body.close
+    end
+  else
+    def write_body_path(sock, body)
+      write_body_stream(sock, body_to_io(body))
+    end
+  end
+
+  if method_defined?(:write_body_path)
+    def write_body(client, body)
+      body.respond_to?(:to_path) ?
+        write_body_path(client, body) :
+        write_body_each(client, body)
+    end
+  else
+    ALIASES[:write_body] = :write_body_each
+  end
+
+  # generic body writer, used for most dynamically generated responses
+  def write_body_each(socket, body)
+    body.each { |chunk| socket.write(chunk) }
+    ensure
+      body.respond_to?(:close) and body.close
+  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/response.rb

@@ -0,0 +1,43 @@
+# -*- encoding: binary -*-
+# :enddoc:
+require 'time' # for Time#httpdate
+
+module Rainbows::Response
+
+  CODES = Unicorn::HttpResponse::CODES
+
+  def response_header(response, out)
+    status, headers = response
+    status = CODES[status.to_i] || status
+
+    headers.each do |key, value|
+      next if %r{\A(?:X-Rainbows-|Connection\z|Date\z|Status\z)}i =~ key
+      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
+    end
+
+    "HTTP/1.1 #{status}\r\n" \
+    "Date: #{Time.now.httpdate}\r\n" \
+    "Status: #{status}\r\n" \
+    "#{out.join('')}\r\n"
+  end
+
+  def write_header(socket, response, out)
+    out and socket.write(response_header(response, out))
+  end
+
+  def write_response(socket, response, out)
+    write_header(socket, response, out)
+    write_body(socket, response[2])
+  end
+
+  # called after forking
+  def self.setup(klass)
+    require('rainbows/response/body') and
+      klass.__send__(:include, Rainbows::Response::Body)
+  end
+end

data/lib/rainbows/rev/client.rb

@@ -1,11 +1,15 @@
 # -*- encoding: binary -*-
+# :enddoc:
 require 'rainbows/ev_core'
 module Rainbows
   module Rev
 
     class Client < ::Rev::IO
+      include Rainbows::ByteSlice
       include Rainbows::EvCore
+      include Rainbows::Response
       G = Rainbows::G
+      HH = Rack::Utils::HeaderHash
 
       def initialize(io)
         CONN[self] = false
@@ -14,6 +18,33 @@ module Rainbows
         @deferred_bodies = [] # for (fast) regular files only
       end
 
+      def quit
+        super
+        close if @deferred_bodies.empty? && @_write_buffer.empty?
+      end
+
+      # override the ::Rev::IO#write method try to write directly to the
+      # kernel socket buffers to avoid an extra userspace copy if
+      # possible.
+      def write(buf)
+        if @_write_buffer.empty?
+          begin
+            w = @_io.write_nonblock(buf)
+            if w == Rack::Utils.bytesize(buf)
+              return on_write_complete
+            end
+            # we never care for the return value, but yes, we may return
+            # a "fake" short write from super(buf) if anybody cares.
+            buf = byte_slice(buf, w..-1)
+          rescue Errno::EAGAIN
+            break # fall through to super(buf)
+          rescue
+            return close
+          end while true
+        end
+        super(buf)
+      end
+
       # queued, optional response bodies, it should only be unpollable "fast"
       # devices where read(2) is uninterruptable.  Unfortunately, NFS and ilk
       # are also part of this.  We'll also stick DeferredResponse bodies in
@@ -27,6 +58,42 @@ module Rainbows
         @_write_buffer.empty? && @deferred_bodies.empty? and close.nil?
       end
 
+      def rev_write_response(response, out)
+        status, headers, body = response
+
+        body.respond_to?(:to_path) or
+          return write_response(self, response, out)
+
+        headers = HH.new(headers)
+        io = body_to_io(body)
+        st = io.stat
+
+        if st.socket? || st.pipe?
+          do_chunk = !!(headers['Transfer-Encoding'] =~ %r{\Achunked\z}i)
+          do_chunk = false if headers.delete('X-Rainbows-Autochunk') == 'no'
+          # too tricky to support keepalive/pipelining when a response can
+          # take an indeterminate amount of time here.
+          if out.nil?
+            do_chunk = false
+          else
+            out[0] = CONN_CLOSE
+          end
+
+          # we only want to attach to the Rev::Loop belonging to the
+          # main thread in Ruby 1.9
+          io = DeferredResponse.new(io, self, do_chunk, body).
+                                    attach(Server::LOOP)
+        elsif st.file?
+          headers.delete('Transfer-Encoding')
+          headers['Content-Length'] ||= st.size.to_s
+          io = to_sendfile(io)
+        else # char/block device, directory, whatever... nobody cares
+          return write_response(self, response, out)
+        end
+        defer_body(io, out)
+        write_header(self, response, out)
+      end
+
       def app_call
         begin
           KATO.delete(self)
@@ -36,7 +103,7 @@ module Rainbows
           alive = @hp.keepalive? && G.alive
           out = [ alive ? CONN_ALIVE : CONN_CLOSE ] if @hp.headers?
 
-          DeferredResponse.write(self, response, out)
+          rev_write_response(response, out)
           if alive
             @env.clear
             @hp.reset
@@ -52,16 +119,16 @@ module Rainbows
       end
 
       def on_write_complete
-        if body = @deferred_bodies.first
+        if body = @deferred_bodies[0]
+          # no socket or pipes, body must be a regular file to continue here
           return if DeferredResponse === body
+
           begin
-            begin
-              write(body.sysread(CHUNK_SIZE))
-            rescue EOFError # expected at file EOF
-              @deferred_bodies.shift
-              body.close
-              close if :close == @state && @deferred_bodies.empty?
-            end
+            rev_sendfile(body)
+          rescue EOFError # expected at file EOF
+            @deferred_bodies.shift
+            body.close
+            close if :close == @state && @deferred_bodies.empty?
           rescue => e
             handle_error(e)
           end
@@ -71,6 +138,9 @@ module Rainbows
       end
 
       def on_close
+        while f = @deferred_bodies.shift
+          DeferredResponse === f or f.close
+        end
         CONN.delete(self)
       end
 

data/lib/rainbows/rev/core.rb

@@ -1,4 +1,5 @@
 # -*- encoding: binary -*-
+# :enddoc:
 require 'rev'
 Rev::VERSION >= '0.3.0' or abort 'rev >= 0.3.0 is required'
 require 'rainbows/rev/heartbeat'
@@ -22,6 +23,9 @@ module Rainbows
       # for connections and doesn't die until the parent dies (or is
       # given a INT, QUIT, or TERM signal)
       def worker_loop(worker)
+        Rainbows::Response.setup(Rainbows::Rev::Client)
+        require 'rainbows/rev/sendfile'
+        Rainbows::Rev::Client.__send__(:include, Rainbows::Rev::Sendfile)
         init_worker_process(worker)
         mod = self.class.const_get(@use)
         rloop = Server.const_set(:LOOP, ::Rev::Loop.default)

data/lib/rainbows/rev/deferred_response.rb

@@ -1,55 +1,12 @@
 # -*- encoding: binary -*-
+# :enddoc:
 module Rainbows
   module Rev
 
     # this is class is specific to Rev for writing large static files
     # or proxying IO-derived objects
     class DeferredResponse < ::Rev::IO
-      include Unicorn
       include Rainbows::Const
-      G = Rainbows::G
-      HH = Rack::Utils::HeaderHash
-
-      def self.write(client, response, out)
-        status, headers, body = response
-
-        body.respond_to?(:to_path) or
-            return HttpResponse.write(client, response, out)
-
-        headers = HH.new(headers)
-
-        # to_io is not part of the Rack spec, but make an exception
-        # here since we can't get here without checking to_path first
-        io = body.to_io if body.respond_to?(:to_io)
-        io ||= ::IO.new($1.to_i) if body.to_path =~ %r{\A/dev/fd/(\d+)\z}
-        io ||= File.open(body.to_path, 'rb')
-        st = io.stat
-
-        if st.socket? || st.pipe?
-          do_chunk = !!(headers['Transfer-Encoding'] =~ %r{\Achunked\z}i)
-          do_chunk = false if headers.delete('X-Rainbows-Autochunk') == 'no'
-          # too tricky to support keepalive/pipelining when a response can
-          # take an indeterminate amount of time here.
-          if out.nil?
-            do_chunk = false
-          else
-            out[0] = CONN_CLOSE
-          end
-
-          # we only want to attach to the Rev::Loop belonging to the
-          # main thread in Ruby 1.9
-          io = new(io, client, do_chunk, body).attach(Server::LOOP)
-        elsif st.file?
-          headers.delete('Transfer-Encoding')
-          headers['Content-Length'] ||= st.size.to_s
-        else # char/block device, directory, whatever... nobody cares
-          return HttpResponse.write(client, response, out)
-        end
-        client.defer_body(io, out)
-        out.nil? or
-          client.write(HttpResponse.header_string(status, headers.to_hash, out))
-      end
-
       def initialize(io, client, do_chunk, body)
         super(io)
         @client, @do_chunk, @body = client, do_chunk, body

data/lib/rainbows/rev/heartbeat.rb

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

data/lib/rainbows/rev/master.rb

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

data/lib/rainbows/rev/sendfile.rb

@@ -0,0 +1,26 @@
+# -*- encoding: binary -*-
+# :enddoc:
+module Rainbows::Rev::Sendfile
+  if IO.method_defined?(:sendfile_nonblock)
+    F = Rainbows::StreamFile
+
+    def to_sendfile(io)
+      F[0, io]
+    end
+
+    def rev_sendfile(body)
+      body.offset += @_io.sendfile_nonblock(body, body.offset, 0x10000)
+      enable_write_watcher
+      rescue Errno::EAGAIN
+        enable_write_watcher
+    end
+  else
+    def to_sendfile(io)
+      io
+    end
+
+    def rev_sendfile(body)
+      write(body.sysread(0x4000))
+    end
+  end
+end

data/lib/rainbows/rev/thread.rb

@@ -1,4 +1,5 @@
 # -*- encoding: binary -*-
+# :enddoc:
 require 'thread'
 require 'rainbows/rev/master'
 
@@ -22,7 +23,7 @@ module Rainbows
         enable
         alive = @hp.keepalive? && G.alive
         out = [ alive ? CONN_ALIVE : CONN_CLOSE ] if @hp.headers?
-        DeferredResponse.write(self, response, out)
+        rev_write_response(response, out)
         return quit unless alive && G.alive
 
         @env.clear

data/lib/rainbows/rev.rb

@@ -25,6 +25,7 @@ module Rainbows
 
   module Rev
 
+    # :stopdoc:
     # keep-alive timeout scoreboard
     KATO = {}
 
@@ -37,5 +38,6 @@ module Rainbows
     end
 
     include Core
+    # :startdoc:
   end
 end

data/lib/rainbows/rev_fiber_spawn.rb

@@ -15,9 +15,11 @@ module Rainbows
     include Base
     include Fiber::Rev
 
-    def worker_loop(worker)
+    def worker_loop(worker) # :nodoc:
+      Rainbows::Response.setup(Rainbows::Fiber::Rev::Server)
       init_worker_process(worker)
       Server.const_set(:MAX, @worker_connections)
+      Rainbows::Fiber::Base.setup(Rainbows::Fiber::Rev::Server, nil)
       Server.const_set(:APP, G.server.app)
       Heartbeat.new(1, true).attach(::Rev::Loop.default)
       kato = Kato.new.attach(::Rev::Loop.default)

data/lib/rainbows/rev_thread_pool.rb

@@ -20,17 +20,19 @@ module Rainbows
 
   module RevThreadPool
 
+    # :stopdoc:
     DEFAULTS = {
       :pool_size => 20, # same default size as ThreadPool (w/o Rev)
     }
+    #:startdoc:
 
-    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"
     end
 
-    class PoolWatcher < ::Rev::TimerWatcher
+    class PoolWatcher < ::Rev::TimerWatcher # :nodoc: all
       def initialize(threads)
         @threads = threads
         super(G.server.timeout, true)
@@ -41,7 +43,7 @@ module Rainbows
       end
     end
 
-    class Client < Rainbows::Rev::ThreadClient
+    class Client < Rainbows::Rev::ThreadClient # :nodoc:
       def app_dispatch
         QUEUE << self
       end
@@ -49,7 +51,7 @@ module Rainbows
 
     include Rainbows::Rev::Core
 
-    def init_worker_threads(master, queue)
+    def init_worker_threads(master, queue) # :nodoc:
       O[:pool_size].times.map do
         Thread.new do
           begin
@@ -62,7 +64,7 @@ module Rainbows
       end
     end
 
-    def init_worker_process(worker)
+    def init_worker_process(worker) # :nodoc:
       super
       master = Rev::Master.new(Queue.new).attach(::Rev::Loop.default)
       queue = Client.const_set(:QUEUE, Queue.new)

data/lib/rainbows/rev_thread_spawn.rb

@@ -20,7 +20,7 @@ module Rainbows
 
   module RevThreadSpawn
 
-    class Client < Rainbows::Rev::ThreadClient
+    class Client < Rainbows::Rev::ThreadClient # :nodoc: all
       def app_dispatch
         Thread.new(self) { |client| MASTER << [ client, app_response ] }
       end
@@ -28,7 +28,7 @@ module Rainbows
 
     include Rainbows::Rev::Core
 
-    def init_worker_process(worker)
+    def init_worker_process(worker) # :nodoc:
       super
       master = Rev::Master.new(Queue.new).attach(::Rev::Loop.default)
       Client.const_set(:MASTER, master)