rainbows 0.95.1 → 0.96.0

data/lib/rainbows/rev/deferred_chunk_response.rb

@@ -0,0 +1,16 @@
+# -*- encoding: binary -*-
+# :enddoc:
+#
+# this is class is specific to Rev for proxying IO-derived objects
+class Rainbows::Rev::DeferredChunkResponse < Rainbows::Rev::DeferredResponse
+  def on_read(data)
+    @client.write("#{data.size.to_s(16)}\r\n")
+    @client.write(data)
+    @client.write("\r\n")
+  end
+
+  def on_close
+    @client.write("0\r\n\r\n")
+    super
+  end
+end

data/lib/rainbows/rev/deferred_response.rb

@@ -1,28 +1,20 @@
 # -*- 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 Rainbows::Rev::DeferredResponse < ::Rev::IO
+  def initialize(io, client, body)
+    super(io)
+    @client, @body = client, body
+  end
 
-    # this is class is specific to Rev for writing large static files
-    # or proxying IO-derived objects
-    class DeferredResponse < ::Rev::IO
-      include Rainbows::Const
-      def initialize(io, client, do_chunk, body)
-        super(io)
-        @client, @do_chunk, @body = client, do_chunk, body
-      end
+  def on_read(data)
+    @client.write(data)
+  end
 
-      def on_read(data)
-        @do_chunk and @client.write(sprintf("%x\r\n", data.size))
-        @client.write(data)
-        @do_chunk and @client.write("\r\n")
-      end
-
-      def on_close
-        @do_chunk and @client.write("0\r\n\r\n")
-        @client.quit
-        @body.respond_to?(:close) and @body.close
-      end
-    end # class DeferredResponse
-  end # module Rev
-end # module Rainbows
+  def on_close
+    @client.next! if @client.attached? # attached? is false if write fails
+    @body.respond_to?(:close) and @body.close
+  end
+end

data/lib/rainbows/rev/sendfile.rb

@@ -2,25 +2,16 @@
 # :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)
+    def rev_sendfile(sf) # +sf+ is a Rainbows::StreamFile object
+      sf.offset += (n = @_io.sendfile_nonblock(sf, sf.offset, sf.count))
+      0 == (sf.count -= n) and raise EOFError
       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))
+      write(body.to_io.sysread(0x4000))
     end
   end
 end

data/lib/rainbows/rev/thread.rb

@@ -13,29 +13,20 @@ module Rainbows
 
       def app_call
         KATO.delete(self)
-        disable
+        disable if enabled?
         @env[RACK_INPUT] = @input
         app_dispatch # must be implemented by subclass
       end
 
       # this is only called in the master thread
       def response_write(response)
-        enable
         alive = @hp.keepalive? && G.alive
-        out = [ alive ? CONN_ALIVE : CONN_CLOSE ] if @hp.headers?
-        rev_write_response(response, out)
-        return quit unless alive && G.alive
+        rev_write_response(response, alive)
+        return quit unless alive && :close != @state
 
         @env.clear
         @hp.reset
         @state = :headers
-        # keepalive requests are always body-less, so @input is unchanged
-        if @hp.headers(@env, @buf)
-          @input = HttpRequest::NULL_IO
-          app_call
-        else
-          KATO[self] = Time.now
-        end
       end
 
       # fails-safe application dispatch, we absolutely cannot

data/lib/rainbows/rev_thread_pool.rb

@@ -15,8 +15,8 @@ module Rainbows
   # slow clients and applications with medium-to-slow response times
   # (I/O bound), but less suitable for sleepy applications.
   #
-  # Ruby 1.8 users are strongly advised to use Rev >= 0.3.2 to get
-  # usable performance.
+  # 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 RevThreadPool
 

data/lib/rainbows/revactor.rb

@@ -22,6 +22,8 @@ module Rainbows::Revactor
   # :stopdoc:
   RD_ARGS = {}
 
+  autoload :Proxy, 'rainbows/revactor/proxy'
+
   include Rainbows::Base
   LOCALHOST = Unicorn::HttpRequest::LOCALHOST
   TCP = ::Revactor::TCP::Socket
@@ -41,7 +43,6 @@ module Rainbows::Revactor
     buf = client.read(*rd_args)
     hp = HttpParser.new
     env = {}
-    alive = true
 
     begin
       buf << client.read(*rd_args) until hp.headers(env, buf)
@@ -50,18 +51,23 @@ module Rainbows::Revactor
       env[RACK_INPUT] = 0 == hp.content_length ?
                NULL_IO : TeeInput.new(PartialSocket.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
+        env = false unless hp.keepalive? && G.alive
+        headers[CONNECTION] = env ? KEEP_ALIVE : CLOSE
+        client.write(response_header(status, headers))
+      end
+      write_body(client, body, range)
+    end while env && env.clear && hp.reset.nil?
   rescue ::Revactor::TCP::ReadError
   rescue => e
     Rainbows::Error.write(io, e)
@@ -74,7 +80,8 @@ module Rainbows::Revactor
   # given a INT, QUIT, or TERM signal)
   def worker_loop(worker) #:nodoc:
     init_worker_process(worker)
-    self.class.__send__(:alias_method, :write_body, :write_body_each)
+    require 'rainbows/revactor/body'
+    self.class.__send__(:include, Rainbows::Revactor::Body)
     RD_ARGS[:timeout] = G.kato if G.kato > 0
     nr = 0
     limit = worker_connections

data/lib/rainbows/revactor/body.rb

@@ -0,0 +1,42 @@
+# -*- encoding: binary -*-
+# :enddoc:
+module Rainbows::Revactor::Body
+  # TODO non-blocking splice(2) under Linux
+  ALIASES = {
+    :write_body_stream => :write_body_each
+  }
+
+  if IO.method_defined?(:sendfile_nonblock)
+    def write_body_file(client, body, range)
+      sock = client.instance_variable_get(:@_io)
+      pfx = ::Revactor::TCP::Socket === client ? :tcp : :unix
+      write_complete = T[:"#{pfx}_write_complete", client]
+      closed = T[:"#{pfx}_closed", client]
+      offset, count = range ? range : [ 0, body.stat.size ]
+      begin
+        offset += (n = sock.sendfile_nonblock(body, offset, count))
+      rescue Errno::EAGAIN
+        # The @_write_buffer is empty at this point, trigger the
+        # on_readable method which in turn triggers on_write_complete
+        # even though nothing was written
+        client.controller = Actor.current
+        client.__send__(:enable_write_watcher)
+        Actor.receive do |filter|
+          filter.when(write_complete) {}
+          filter.when(closed) { raise Errno::EPIPE }
+        end
+        retry
+      rescue EOFError
+        break
+      end while (count -= n) > 0
+    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/revactor/proxy.rb

@@ -0,0 +1,55 @@
+# -*- encoding: binary -*-
+# :enddoc:
+# Generic IO wrapper for proxying pipe and socket objects
+# this behaves more like Rainbows::Fiber::IO than anything,
+# making it highly suitable for proxying data from pipes/sockets
+class Rainbows::Revactor::Proxy < Rev::IO
+  def initialize(io)
+    @receiver = Actor.current
+    super(io)
+    attach(Rev::Loop.default)
+  end
+
+  def close
+    if @_io
+      super
+      @_io = nil
+    end
+  end
+
+  def each(&block)
+    # when yield-ing, Revactor::TCP#write may raise EOFError
+    # (instead of Errno::EPIPE), so we need to limit the rescue
+    # to just readpartial and let EOFErrors during yield bubble up
+    begin
+      buf = readpartial(INPUT_SIZE)
+    rescue EOFError
+      break
+    end while yield(buf) || true
+  end
+
+  # this may return more than the specified length, Rainbows! won't care...
+  def readpartial(length)
+    @receiver = Actor.current
+    enable if attached? && ! enabled?
+
+    Actor.receive do |filter|
+      filter.when(T[:rainbows_io_input, self]) do |_, _, data|
+        return data
+      end
+
+      filter.when(T[:rainbows_io_closed, self]) do
+        raise EOFError, "connection closed"
+      end
+    end
+  end
+
+  def on_close
+    @receiver << T[:rainbows_io_closed, self]
+  end
+
+  def on_read(data)
+    @receiver << T[:rainbows_io_input, self, data ]
+    disable
+  end
+end

data/lib/rainbows/sendfile.rb

@@ -1,6 +1,4 @@
 # -*- encoding: binary -*-
-module Rainbows
-
 # This middleware handles X-\Sendfile headers generated by applications
 # or middlewares down the stack.  It should be placed at the top
 # (outermost layer) of the middleware stack to avoid having its
@@ -48,42 +46,42 @@ module Rainbows
 #      ]
 #    }
 
-class Sendfile < Struct.new(:app)
-
-  # :stopdoc:
-  HH = Rack::Utils::HeaderHash
-  # :startdoc:
+class Rainbows::Sendfile < Struct.new(:app)
 
   # Body wrapper, this allows us to fall back gracefully to
   # +each+ in case a given concurrency model does not optimize
   # +to_path+ calls.
   class Body < Struct.new(:to_path) # :nodoc: all
+    CONTENT_LENGTH = 'Content-Length'.freeze
 
     def self.new(path, headers)
-      unless headers['Content-Length']
+      unless headers[CONTENT_LENGTH]
         stat = File.stat(path)
-        headers['Content-Length'] = stat.size.to_s if stat.file?
+        headers[CONTENT_LENGTH] = stat.size.to_s if stat.file?
       end
       super(path)
     end
 
     # fallback in case our +to_path+ doesn't get handled for whatever reason
     def each(&block)
-      File.open(to_path, 'rb') do |fp|
-        buf = ''
+      buf = ''
+      File.open(to_path) do |fp|
         yield buf while fp.read(0x4000, buf)
       end
     end
   end
 
+  # :stopdoc:
+  HH = Rack::Utils::HeaderHash
+  X_SENDFILE = 'X-Sendfile'
+  # :startdoc:
+
   def call(env) # :nodoc:
     status, headers, body = app.call(env)
     headers = HH.new(headers)
-    if path = headers.delete('X-Sendfile')
+    if path = headers.delete(X_SENDFILE)
       body = Body.new(path, headers) unless body.respond_to?(:to_path)
     end
     [ status, headers, body ]
   end
 end
-
-end

data/lib/rainbows/stream_file.rb

@@ -5,10 +5,10 @@
 # models.  We always maintain our own file offsets in userspace because
 # because sendfile() implementations offer pread()-like idempotency for
 # concurrency (multiple clients can read the same underlying file handle).
-class Rainbows::StreamFile < Struct.new(:offset, :to_io)
-
+class Rainbows::StreamFile < Struct.new(:offset, :count, :to_io, :body)
   def close
-    to_io.close
+    body.close if body.respond_to?(:close)
+    to_io.close unless to_io.closed?
     self.to_io = nil
   end
 end

data/lib/rainbows/writer_thread_pool.rb

@@ -46,33 +46,33 @@ module Rainbows
       end
     end
 
-    module Response # :nodoc:
-      def write_body(qclient, body)
-        qclient.q << [ qclient.to_io, :body, body ]
-      end
-    end
-
     @@nr = 0
     @@q = nil
 
+    def async_write_body(qclient, body, range)
+      qclient.q << [ qclient.to_io, :body, body, range ]
+    end
+
     def process_client(client) # :nodoc:
       @@nr += 1
-      super(QueueSocket[client, @@q[@@nr %= @@q.size]])
+      super(QueueSocket.new(client, @@q[@@nr %= @@q.size]))
     end
 
-    def worker_loop(worker) # :nodoc:
-      Rainbows::Response.setup(self.class)
+    def init_worker_process(worker)
+      super
       self.class.__send__(:alias_method, :sync_write_body, :write_body)
-      self.class.__send__(:include, Response)
+      WriterThreadPool.__send__(:alias_method, :write_body, :async_write_body)
+    end
 
+    def worker_loop(worker) # :nodoc:
       # we have multiple, single-thread queues since we don't want to
       # interleave writes from the same client
       qp = (1..worker_connections).map do |n|
         QueuePool.new(1) do |response|
           begin
-            io, arg1, arg2 = response
+            io, arg1, arg2, arg3 = response
             case arg1
-            when :body then sync_write_body(io, arg2)
+            when :body then sync_write_body(io, arg2, arg3)
             when :close then io.close unless io.closed?
             else
               io.write(arg1)

data/lib/rainbows/writer_thread_spawn.rb

@@ -51,9 +51,9 @@ module Rainbows
         self.thr = Thread.new(to_io, q) do |io, q|
           while response = q.shift
             begin
-              arg1, arg2 = response
+              arg1, arg2, arg3 = response
               case arg1
-              when :body then write_body(io, arg2)
+              when :body then write_body(io, arg2, arg3)
               when :close
                 io.close unless io.closed?
                 break
@@ -73,8 +73,8 @@ module Rainbows
         (self.q ||= queue_writer) << buf
       end
 
-      def queue_body(body)
-        (self.q ||= queue_writer) << [ :body, body ]
+      def queue_body(body, range)
+        (self.q ||= queue_writer) << [ :body, body, range ]
       end
 
       def close
@@ -90,8 +90,8 @@ module Rainbows
       end
     end
 
-    def write_body(my_sock, body) # :nodoc:
-      my_sock.queue_body(body)
+    def write_body(my_sock, body, range) # :nodoc:
+      my_sock.queue_body(body, range)
     end
 
     def process_client(client) # :nodoc:
@@ -100,7 +100,6 @@ module Rainbows
 
     def worker_loop(worker)  # :nodoc:
       MySocket.const_set(:MAX, worker_connections)
-      Rainbows::Response.setup(MySocket)
       super(worker) # accept loop from Unicorn
       CUR.delete_if do |t,q|
         q << nil