rainbows 0.95.1 → 0.96.0

data/lib/rainbows/event_machine/response_chunk_pipe.rb

@@ -0,0 +1,25 @@
+# -*- encoding: binary -*-
+# :enddoc:
+module Rainbows::EventMachine::ResponseChunkPipe
+  include Rainbows::EventMachine::ResponsePipe
+
+  def unbind
+    @client.write("0\r\n\r\n")
+    super
+  end
+
+  def notify_readable
+    begin
+      data = @io.read_nonblock(16384, BUF)
+      @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
+      return
+    end while true
+  end
+end

data/lib/rainbows/event_machine/response_pipe.rb

@@ -0,0 +1,30 @@
+# -*- encoding: binary -*-
+# :enddoc:
+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 = ''
+
+  def initialize(client, alive, body)
+    @client, @alive, @body = client, alive, body
+  end
+
+  def notify_readable
+    begin
+      @client.write(@io.read_nonblock(16384, BUF))
+    rescue Errno::EINTR
+    rescue Errno::EAGAIN
+      return
+    rescue EOFError
+      detach
+      return
+    end while true
+  end
+
+  def unbind
+    @client.body = nil
+    @alive ? @client.on_read('') : @client.quit
+    @body.close if @body.respond_to?(:close)
+    @io.close unless @io.closed?
+  end
+end

data/lib/rainbows/event_machine/try_defer.rb

@@ -0,0 +1,27 @@
+# -*- encoding: binary -*-
+# :enddoc:
+
+# 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 Rainbows::EventMachine::TryDefer < Struct.new(:app)
+  # shortcuts
+  ASYNC_CALLBACK = Rainbows::EvCore::ASYNC_CALLBACK
+
+  def initialize(app)
+    # the entire app becomes multithreaded, even the root (non-deferred)
+    # thread since any thread can share processes with others
+    Rainbows::Const::RACK_DEFAULTS['rack.multithread'] = true
+    super
+  end
+
+  def call(env)
+    if app.deferred?(env)
+      EM.defer(proc { catch(:async) { app.call(env) } }, env[ASYNC_CALLBACK])
+      # all of the async/deferred stuff breaks Rack::Lint :<
+      nil
+    else
+      app.call(env)
+    end
+  end
+end

data/lib/rainbows/fiber/body.rb

@@ -12,15 +12,17 @@ module Rainbows::Fiber::Body # :nodoc:
 
   # 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
+    def write_body_file(client, body, range)
+      sock, n = client.to_io, nil
+      offset, count = range ? range : [ 0, body.stat.size ]
       begin
-        off += sock.sendfile_nonblock(body, off, 0x10000)
+        offset += (n = sock.sendfile_nonblock(body, offset, count))
       rescue Errno::EAGAIN
         client.wait_writable
+        retry
       rescue EOFError
         break
-      end while true
+      end while (count -= n) > 0
     end
   else
     ALIASES[:write_body] = :write_body_each

data/lib/rainbows/fiber/io.rb

@@ -24,11 +24,11 @@ module Rainbows
 
       # for wrapping output response bodies
       def each(&block)
-        begin
-          yield readpartial(16384)
+        if buf = readpartial(16384)
+          yield buf
+          yield buf while readpartial(16384, buf)
+        end
         rescue EOFError
-          break
-        end while true
         self
       end
 

data/lib/rainbows/fiber/rev.rb

@@ -81,7 +81,6 @@ module Rainbows::Fiber
         buf = client.read_timeout or return
         hp = HttpParser.new
         env = {}
-        alive = true
         remote_addr = Rainbows.addr(io)
 
         begin # loop
@@ -91,18 +90,27 @@ module Rainbows::Fiber
           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))
+          status, headers, body = APP.call(env.update(RACK_DEFAULTS))
 
-          if 100 == response[0].to_i
+          if 100 == status.to_i
             client.write(EXPECT_100_RESPONSE)
             env.delete(HTTP_EXPECT)
-            response = APP.call(env)
+            status, headers, body = APP.call(env)
           end
 
-          alive = hp.keepalive? && G.alive
-          out = [ alive ? CONN_ALIVE : CONN_CLOSE ] if hp.headers?
-          write_response(client, response, out)
-        end while alive and hp.reset.nil? and env.clear
+          if hp.headers?
+            headers = HH.new(headers)
+            range = make_range!(env, status, headers) and status = range.shift
+            headers[CONNECTION] = if hp.keepalive? && G.alive
+              KEEP_ALIVE
+            else
+              env = false
+              CLOSE
+            end
+            client.write(response_header(status, headers))
+          end
+          write_body(client, body, range)
+        end while env && env.clear && hp.reset.nil?
       rescue => e
         Error.write(io, e)
       ensure

data/lib/rainbows/http_response.rb

@@ -4,20 +4,19 @@
 # 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
+    # dummy method for Cramp to alias_method_chain
+    def self.write(client, response, out)
     end
   end
 
   module Rainbows::EventMachine::CrampSocket
-    def write_header(_, response, out)
+    def em_write_response(response, alive = false)
       if websocket?
         write web_socket_upgrade_data
         web_socket_handshake!
-        out = nil # disable response headers
+        response[1] = nil # disable response headers
       end
-      super(self, response, out)
+      super
     end
   end
 

data/lib/rainbows/response.rb

@@ -3,41 +3,56 @@
 require 'time' # for Time#httpdate
 
 module Rainbows::Response
+  autoload :Body, 'rainbows/response/body'
+  autoload :Range, 'rainbows/response/range'
 
   CODES = Unicorn::HttpResponse::CODES
+  CRLF = "\r\n"
 
-  def response_header(response, out)
-    status, headers = response
-    status = CODES[status.to_i] || status
+  # freeze headers we may set as hash keys for a small speedup
+  CONNECTION = "Connection".freeze
+  CLOSE = "close"
+  KEEP_ALIVE = "keep-alive"
+  HH = Rack::Utils::HeaderHash
 
+  def response_header(status, headers)
+    status = CODES[status.to_i] || status
+    rv = "HTTP/1.1 #{status}\r\n" \
+         "Date: #{Time.now.httpdate}\r\n" \
+         "Status: #{status}\r\n"
     headers.each do |key, value|
-      next if %r{\A(?:X-Rainbows-|Connection\z|Date\z|Status\z)}i =~ key
+      next if %r{\A(?:X-Rainbows-|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" })
+        rv << value.split(/\n+/).map! { |v| "#{key}: #{v}\r\n" }.join('')
       else
-        out << "#{key}: #{value}\r\n"
+        rv << "#{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])
+    rv << CRLF
   end
 
   # called after forking
   def self.setup(klass)
-    require('rainbows/response/body') and
-      klass.__send__(:include, Rainbows::Response::Body)
+    range_class = body_class = klass
+    case Rainbows::Const::RACK_DEFAULTS['rainbows.model']
+    when :WriterThreadSpawn
+      body_class = Rainbows::WriterThreadSpawn::MySocket
+      range_class = Rainbows::HttpServer
+    when :EventMachine, :NeverBlock
+      range_class = nil # :<
+    end
+    return if body_class.included_modules.include?(Body)
+    body_class.__send__(:include, Body)
+    sf = IO.respond_to?(:copy_stream) || IO.method_defined?(:sendfile_nonblock)
+    if range_class
+      range_class.__send__(:include, sf ? Range : NoRange)
+    end
+  end
+
+  module NoRange
+    # dummy method if we can't send range responses
+    def make_range!(env, status, headers)
+    end
   end
 end

data/lib/rainbows/response/body.rb

@@ -41,27 +41,28 @@ module Rainbows::Response::Body # :nodoc:
       # 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')
+      path =~ %r{\A/dev/fd/(\d+)\z} ? IO.new($1.to_i) : File.open(path)
     end
   end
 
   if IO.method_defined?(:sendfile_nonblock)
-    def write_body_file(sock, body)
-      sock.sendfile(body, 0)
+    def write_body_file(sock, body, range)
+      range ? sock.sendfile(body, range[0], range[1]) : 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)
+      def write_body_file(sock, body, range)
+        range ? IO.copy_stream(body, sock, range[1], range[0]) :
+                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)
+    def write_body_stream(sock, body, range)
       IO.copy_stream(body, sock)
       ensure
         body.respond_to?(:close) and body.close
@@ -74,38 +75,40 @@ module Rainbows::Response::Body # :nodoc:
   if method_defined?(:write_body_file)
 
     # middlewares/apps may return with a body that responds to +to_path+
-    def write_body_path(sock, body)
+    def write_body_path(sock, body, range)
       inp = body_to_io(body)
       if inp.stat.file?
         begin
-          write_body_file(sock, inp)
+          write_body_file(sock, inp, range)
         ensure
           inp.close if inp != body
         end
       else
-        write_body_stream(sock, inp)
+        write_body_stream(sock, inp, range)
       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))
+  elsif method_defined?(:write_body_stream)
+    def write_body_path(sock, body, range)
+      write_body_stream(sock, inp = body_to_io(body), range)
+      ensure
+        body.respond_to?(:close) && inp != body and body.close
     end
   end
 
   if method_defined?(:write_body_path)
-    def write_body(client, body)
+    def write_body(client, body, range)
       body.respond_to?(:to_path) ?
-        write_body_path(client, body) :
-        write_body_each(client, body)
+        write_body_path(client, body, range) :
+        write_body_each(client, body, range)
     end
   else
     ALIASES[:write_body] = :write_body_each
   end
 
   # generic body writer, used for most dynamically generated responses
-  def write_body_each(socket, body)
+  def write_body_each(socket, body, range = nil)
     body.each { |chunk| socket.write(chunk) }
     ensure
       body.respond_to?(:close) and body.close

data/lib/rainbows/response/range.rb

@@ -0,0 +1,34 @@
+# -*- encoding: binary -*-
+# :enddoc:
+module Rainbows::Response::Range
+  HTTP_RANGE = 'HTTP_RANGE'
+  Content_Range = 'Content-Range'.freeze
+  Content_Length = 'Content-Length'.freeze
+
+  # This does not support multipart responses (does anybody actually
+  # use those?) +headers+ is always a Rack::Utils::HeaderHash
+  def make_range!(env, status, headers)
+    if 200 == status.to_i &&
+        (clen = headers[Content_Length]) &&
+        /\Abytes=(\d+-\d*|\d*-\d+)\z/ =~ env[HTTP_RANGE]
+      a, b = $1.split(/-/)
+      clen = clen.to_i
+      if b.nil? # bytes=M-
+        offset = a.to_i
+        count = clen - offset
+      elsif a.empty? # bytes=-N
+        offset = clen - b.to_i
+        count = clen - offset
+      else  # bytes=M-N
+        offset = a.to_i
+        count = b.to_i + 1 - offset
+      end
+      raise Rainbows::Response416 if count <= 0 || offset >= clen
+      count = clen if count > clen
+      headers[Content_Length] = count.to_s
+      headers[Content_Range] = "bytes #{offset}-#{offset+count-1}/#{clen}"
+      [ status, offset, count ]
+    end
+    # nil if no status
+  end
+end

data/lib/rainbows/rev.rb

@@ -1,7 +1,6 @@
 # -*- encoding: binary -*-
 require 'rainbows/rev/core'
 require 'rainbows/rev/client'
-require 'rainbows/rev/deferred_response'
 
 module Rainbows
 
@@ -37,6 +36,8 @@ module Rainbows
       KATO.compare_by_identity
     end
 
+    autoload :DeferredResponse,'rainbows/rev/deferred_response'
+    autoload :DeferredChunkResponse,'rainbows/rev/deferred_chunk_response'
     include Core
     # :startdoc:
   end

data/lib/rainbows/rev/client.rb

@@ -7,20 +7,19 @@ module Rainbows
     class Client < ::Rev::IO
       include Rainbows::ByteSlice
       include Rainbows::EvCore
-      include Rainbows::Response
       G = Rainbows::G
-      HH = Rack::Utils::HeaderHash
+      F = Rainbows::StreamFile
 
       def initialize(io)
         CONN[self] = false
         super(io)
         post_init
-        @deferred_bodies = [] # for (fast) regular files only
+        @deferred = nil
       end
 
       def quit
         super
-        close if @deferred_bodies.empty? && @_write_buffer.empty?
+        close if @deferred.nil? && @_write_buffer.empty?
       end
 
       # override the ::Rev::IO#write method try to write directly to the
@@ -30,16 +29,14 @@ module Rainbows
         if @_write_buffer.empty?
           begin
             w = @_io.write_nonblock(buf)
-            if w == Rack::Utils.bytesize(buf)
-              return on_write_complete
-            end
+            return enable_write_watcher if w == Rack::Utils.bytesize(buf)
             # 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
+          rescue => e
+            return handle_error(e)
           end while true
         end
         super(buf)
@@ -49,98 +46,129 @@ module Rainbows
       # devices where read(2) is uninterruptable.  Unfortunately, NFS and ilk
       # are also part of this.  We'll also stick DeferredResponse bodies in
       # here to prevent connections from being closed on us.
-      def defer_body(io, out_headers)
-        @deferred_bodies << io
-        schedule_write unless out_headers # triggers a write
+      def defer_body(io)
+        @deferred = io
+        enable_write_watcher
       end
 
-      def timeout?
-        @_write_buffer.empty? && @deferred_bodies.empty? and close.nil?
+      # allows enabling of write watcher even when read watcher is disabled
+      def evloop
+        Rainbows::Rev::Server::LOOP
       end
 
-      def rev_write_response(response, out)
-        status, headers, body = response
+      def next!
+        @deferred = nil
+        on_write_complete
+      end
 
-        body.respond_to?(:to_path) or
-          return write_response(self, response, out)
+      def timeout?
+        @deferred.nil? && @_write_buffer.empty? and close.nil?
+      end
 
-        headers = HH.new(headers)
-        io = body_to_io(body)
-        st = io.stat
+      # used for streaming sockets and pipes
+      def stream_response(status, headers, io, body)
+        c = stream_response_headers(status, headers) if headers
+        # we only want to attach to the Rev::Loop belonging to the
+        # main thread in Ruby 1.9
+        io = (c ? DeferredChunkResponse : DeferredResponse).new(io, self, body)
+        defer_body(io.attach(Server::LOOP))
+      end
 
-        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
+      def rev_write_response(response, alive)
+        status, headers, body = response
+        headers = @hp.headers? ? HH.new(headers) : nil
+
+        headers[CONNECTION] = alive ? KEEP_ALIVE : CLOSE if headers
+        if body.respond_to?(:to_path)
+          io = body_to_io(body)
+          st = io.stat
+
+          if st.file?
+            offset, count = 0, st.size
+            if headers
+              if range = make_range!(@env, status, headers)
+                status, offset, count = range
+              end
+              write(response_header(status, headers))
+            end
+            return defer_body(F.new(offset, count, io, body))
+          elsif st.socket? || st.pipe?
+            return stream_response(status, headers, io, body)
           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)
+          # char or block device... WTF? fall through to body.each
         end
-        defer_body(io, out)
-        write_header(self, response, out)
+        write(response_header(status, headers)) if headers
+        write_body_each(self, body, nil)
       end
 
       def app_call
-        begin
-          KATO.delete(self)
-          @env[RACK_INPUT] = @input
-          @env[REMOTE_ADDR] = @remote_addr
-          response = APP.call(@env.update(RACK_DEFAULTS))
-          alive = @hp.keepalive? && G.alive
-          out = [ alive ? CONN_ALIVE : CONN_CLOSE ] if @hp.headers?
-
-          rev_write_response(response, out)
-          if alive
-            @env.clear
-            @hp.reset
-            @state = :headers
-            # keepalive requests are always body-less, so @input is unchanged
-            @hp.headers(@env, @buf) and next
-            KATO[self] = Time.now
+        KATO.delete(self)
+        @env[RACK_INPUT] = @input
+        @env[REMOTE_ADDR] = @remote_addr
+        response = APP.call(@env.update(RACK_DEFAULTS))
+
+        rev_write_response(response, alive = @hp.keepalive? && G.alive)
+        return quit unless alive && :close != @state
+        @env.clear
+        @hp.reset
+        @state = :headers
+        disable if enabled?
+      end
+
+      def on_write_complete
+        case @deferred
+        when DeferredResponse then return
+        when NilClass # fall through
+        else
+          begin
+            return rev_sendfile(@deferred)
+          rescue EOFError # expected at file EOF
+            close_deferred
+          end
+        end
+
+        case @state
+        when :close
+          close if @_write_buffer.empty?
+        when :headers
+          if @hp.headers(@env, @buf)
+            app_call
           else
-            quit
+            unless enabled?
+              enable
+              KATO[self] = Time.now
+            end
           end
-          return
-        end while true
+        end
+        rescue => e
+          handle_error(e)
       end
 
-      def on_write_complete
-        if body = @deferred_bodies[0]
-          # no socket or pipes, body must be a regular file to continue here
-          return if DeferredResponse === body
+      def handle_error(e)
+        close_deferred
+        if msg = Error.response(e)
+          @_io.write_nonblock(msg) rescue nil
+        end
+        @_write_buffer.clear
+        ensure
+          quit
+      end
 
+      def close_deferred
+        case @deferred
+        when DeferredResponse, NilClass
+        else
           begin
-            rev_sendfile(body)
-          rescue EOFError # expected at file EOF
-            @deferred_bodies.shift
-            body.close
-            close if :close == @state && @deferred_bodies.empty?
+            @deferred.close
           rescue => e
-            handle_error(e)
+            G.server.logger.error("closing #@deferred: #{e}")
           end
-        else
-          close if :close == @state
+          @deferred = nil
         end
       end
 
       def on_close
-        while f = @deferred_bodies.shift
-          DeferredResponse === f or f.close
-        end
+        close_deferred
         CONN.delete(self)
       end