rainbows 3.0.0 → 3.1.0

data/lib/rainbows/coolio_fiber_spawn.rb

@@ -2,12 +2,12 @@
 require 'rainbows/fiber/coolio'
 
 # A combination of the Coolio and FiberSpawn models.  This allows Ruby
-# 1.9 Fiber-based concurrency for application processing while
-# exposing a synchronous execution model and using scalable network
-# concurrency provided by Cool.io.  A "rack.input" is exposed as well
-# being Sunshowers-compatible.  Applications are strongly advised to
-# wrap all slow IO objects (sockets, pipes) using the
-# Rainbows::Fiber::IO or a Cool.io-compatible class whenever possible.
+# 1.9 Fiber-based concurrency for application processing while exposing
+# a synchronous execution model and using scalable network concurrency
+# provided by Cool.io.  A streaming "rack.input" is exposed.
+# Applications are strongly advised to wrap all slow IO objects
+# (sockets, pipes) using the Rainbows::Fiber::IO or a Cool.io-compatible
+# class whenever possible.
 module Rainbows::CoolioFiberSpawn
 
   include Rainbows::Base

data/lib/rainbows/dev_fd_response.rb

@@ -15,6 +15,13 @@ class Rainbows::DevFdResponse < Struct.new(:app)
 
   # :stopdoc:
   FD_MAP = Rainbows::FD_MAP
+  Content_Length = "Content-Length".freeze
+  Transfer_Encoding = "Transfer-Encoding".freeze
+  Rainbows_autochunk = "rainbows.autochunk".freeze
+  Rainbows_model = "rainbows.model"
+  HTTP_1_0 = "HTTP/1.0"
+  HTTP_VERSION = "HTTP_VERSION"
+  Chunked = "chunked"
 
   # make this a no-op under Rubinius, it's pointless anyways
   # since Rubinius doesn't have IO.copy_stream
@@ -44,19 +51,19 @@ class Rainbows::DevFdResponse < Struct.new(:app)
     fileno = io.fileno
     FD_MAP[fileno] = io
     if st.file?
-      headers['Content-Length'] ||= st.size.to_s
-      headers.delete('Transfer-Encoding')
+      headers[Content_Length] ||= st.size.to_s
+      headers.delete(Transfer_Encoding)
     elsif st.pipe? || st.socket? # epoll-able things
-      unless headers.include?('Content-Length')
-        if env['rainbows.autochunk']
-          headers['Transfer-Encoding'] = 'chunked'
+      unless headers.include?(Content_Length)
+        if env[Rainbows_autochunk] && HTTP_1_0 != env[HTTP_VERSION]
+          headers[Transfer_Encoding] = Chunked
         else
-          headers['X-Rainbows-Autochunk'] = 'no'
+          env[Rainbows_autochunk] = false
         end
       end
 
       # we need to make sure our pipe output is Fiber-compatible
-      case env["rainbows.model"]
+      case env[Rainbows_model]
       when :FiberSpawn, :FiberPool, :RevFiberSpawn, :CoolioFiberSpawn
         io.respond_to?(:kgio_wait_readable) or
           io = Rainbows::Fiber::IO.new(io)
@@ -72,8 +79,8 @@ class Rainbows::DevFdResponse < Struct.new(:app)
   class Body < Struct.new(:to_io, :to_path, :orig_body)
     # called by the webserver or other middlewares if they can't
     # handle #to_path
-    def each(&block)
-      to_io.each(&block)
+    def each
+      to_io.each { |x| yield x }
     end
 
     # remain Rack::Lint-compatible for people with wonky systems :P

data/lib/rainbows/epoll.rb

@@ -0,0 +1,43 @@
+# -*- encoding: binary -*-
+# :enddoc:
+require 'sleepy_penguin'
+require 'sendfile'
+
+# Edge-triggered epoll concurrency model.  This is extremely unfair
+# and optimized for throughput at the expense of fairness
+module Rainbows::Epoll
+  include Rainbows::Base
+  ReRun = []
+  autoload :Server, 'rainbows/epoll/server'
+  autoload :Client, 'rainbows/epoll/client'
+  autoload :ResponsePipe, 'rainbows/epoll/response_pipe'
+  autoload :ResponseChunkPipe, 'rainbows/epoll/response_chunk_pipe'
+  class << self
+    attr_writer :nr_clients
+  end
+
+  def self.loop
+    timeout = Rainbows.server.timeout
+    begin
+      EP.wait(nil, timeout) { |flags, obj| obj.epoll_run }
+      while obj = ReRun.shift
+        obj.epoll_run
+      end
+      Rainbows::Epoll::Client.expire
+    rescue Errno::EINTR
+    rescue => e
+      Rainbows::Error.listen_loop(e)
+    end while Rainbows.tick || @nr_clients.call > 0
+  end
+
+  def init_worker_process(worker)
+    super
+    Rainbows::Epoll.const_set :EP, SleepyPenguin::Epoll.new
+    Rainbows::Client.__send__ :include, Client
+  end
+
+  def worker_loop(worker) # :nodoc:
+    init_worker_process(worker)
+    Server.run
+  end
+end

data/lib/rainbows/epoll/client.rb

@@ -0,0 +1,232 @@
+# -*- encoding: binary -*-
+# :enddoc:
+
+module Rainbows::Epoll::Client
+
+  include Rainbows::EvCore
+  APP = Rainbows.server.app
+  Server = Rainbows::Epoll::Server
+  IN = SleepyPenguin::Epoll::IN | SleepyPenguin::Epoll::ET
+  OUT = SleepyPenguin::Epoll::OUT | SleepyPenguin::Epoll::ET
+  KATO = {}
+  KATO.compare_by_identity if KATO.respond_to?(:compare_by_identity)
+  KEEPALIVE_TIMEOUT = Rainbows.keepalive_timeout
+  EP = Rainbows::Epoll::EP
+  @@last_expire = Time.now
+
+  def self.expire
+    return if ((now = Time.now) - @@last_expire) < 1.0
+    if (ot = KEEPALIVE_TIMEOUT) >= 0
+      ot = now - ot
+      KATO.delete_if { |client, time| time < ot and client.timeout! }
+    end
+    @@last_expire = now
+  end
+
+  # only call this once
+  def epoll_once
+    @wr_queue = [] # may contain String, ResponsePipe, and StreamFile objects
+    post_init
+    on_readable
+    rescue => e
+      handle_error(e)
+  end
+
+  def on_readable
+    case rv = kgio_tryread(16384, RBUF)
+    when String
+      on_read(rv)
+      return if @wr_queue[0] || closed?
+    when :wait_readable
+      KATO[self] = @@last_expire if :headers == @state
+      return EP.set(self, IN)
+    else
+      break
+    end until :close == @state
+    close unless closed?
+    rescue Errno::ECONNRESET
+      close
+    rescue IOError
+  end
+
+  def app_call input # called by on_read()
+    @env[RACK_INPUT] = input
+    @env[REMOTE_ADDR] = kgio_addr
+    status, headers, body = APP.call(@env.merge!(RACK_DEFAULTS))
+    ev_write_response(status, headers, body, @hp.next?)
+  end
+
+  def write_response_path(status, headers, body, alive)
+    io = body_to_io(body)
+    st = io.stat
+
+    if st.file?
+      defer_file(status, headers, body, alive, io, st)
+    elsif st.socket? || st.pipe?
+      chunk = stream_response_headers(status, headers, alive)
+      stream_response_body(body, io, chunk)
+    else
+      # char or block device... WTF?
+      write_response(status, headers, body, alive)
+    end
+  end
+
+  # used for streaming sockets and pipes
+  def stream_response_body(body, io, chunk)
+    pipe = (chunk ? Rainbows::Epoll::ResponseChunkPipe :
+                    Rainbows::Epoll::ResponsePipe).new(io, self, body)
+    return @wr_queue << pipe if @wr_queue[0]
+    stream_pipe(pipe) or return
+    @wr_queue[0] or @wr_queue << Z
+  end
+
+  def ev_write_response(status, headers, body, alive)
+    if body.respond_to?(:to_path)
+      write_response_path(status, headers, body, alive)
+    else
+      write_response(status, headers, body, alive)
+    end
+    @state = alive ? :headers : :close
+    on_read(Z) if alive && 0 == @wr_queue.size && 0 != @buf.size
+  end
+
+  def epoll_run
+    if @wr_queue[0]
+      on_writable
+    else
+      KATO.delete self
+      on_readable
+    end
+  end
+
+  def want_more
+    Rainbows::Epoll::ReRun << self
+  end
+
+  def on_deferred_write_complete
+    :close == @state and return close
+    0 == @buf.size ? on_readable : on_read(Z)
+  end
+
+  def handle_error(e)
+    msg = Rainbows::Error.response(e) and kgio_trywrite(msg) rescue nil
+    ensure
+      close
+  end
+
+  def write_deferred(obj)
+    Rainbows::StreamFile === obj ? stream_file(obj) : stream_pipe(obj)
+  end
+
+  # writes until our write buffer is empty or we block
+  # returns true if we're done writing everything
+  def on_writable
+    obj = @wr_queue.shift
+
+    case rv = String === obj ? kgio_trywrite(obj) : write_deferred(obj)
+    when nil
+      obj = @wr_queue.shift or return on_deferred_write_complete
+    when String
+      obj = rv # retry
+    when :wait_writable # Strings and StreamFiles only
+      @wr_queue.unshift(obj)
+      EP.set(self, OUT)
+      return
+    when :deferred
+      return
+    end while true
+    rescue => e
+      handle_error(e)
+  end
+
+  def write(buf)
+    unless @wr_queue[0]
+      case rv = kgio_trywrite(buf)
+      when nil
+        return # all written
+      when String
+        buf = rv # retry
+      when :wait_writable
+        @wr_queue << buf.dup # >3-word 1.9 strings are copy-on-write
+        return EP.set(self, OUT)
+      end while true
+    end
+    @wr_queue << buf.dup # >3-word 1.9 strings are copy-on-write
+  end
+
+  def close
+    @wr_queue.each { |x| x.respond_to?(:close) and x.close rescue nil }
+    super
+    on_close
+  end
+
+  def on_close
+    KATO.delete(self)
+    Server.decr
+  end
+
+  def timeout!
+    close
+    true
+  end
+
+  def defer_file(status, headers, body, alive, io, st)
+    if r = sendfile_range(status, headers)
+      status, headers, range = r
+      write_headers(status, headers, alive)
+      range and defer_file_stream(range[0], range[1], io, body)
+    else
+      write_headers(status, headers, alive)
+      defer_file_stream(0, st.size, io, body)
+    end
+  end
+
+  # returns +nil+ on EOF, :wait_writable if the client blocks
+  def stream_file(sf) # +sf+ is a Rainbows::StreamFile object
+    begin
+      sf.offset += (n = sendfile_nonblock(sf, sf.offset, sf.count))
+      0 == (sf.count -= n) and return sf.close
+    rescue Errno::EAGAIN
+      return :wait_writable
+    rescue
+      sf.close
+      raise
+    end while true
+  end
+
+  def defer_file_stream(offset, count, io, body)
+    sf = Rainbows::StreamFile.new(offset, count, io, body)
+    unless @wr_queue[0]
+      stream_file(sf) or return
+    end
+    @wr_queue << sf
+    EP.set(self, OUT)
+  end
+
+  # this alternates between a push and pull model from the pipe -> client
+  # to avoid having too much data in userspace on either end.
+  def stream_pipe(pipe)
+    case buf = pipe.tryread
+    when String
+      write(buf)
+      if @wr_queue[0]
+        # client is blocked on write, client will pull from pipe later
+        EP.delete pipe
+        @wr_queue << pipe
+        EP.set(self, OUT)
+        return :deferred
+      end
+      # continue looping...
+    when :wait_readable
+      # pipe blocked on read, let the pipe push to the client in the future
+      EP.delete self
+      EP.set(pipe, IN)
+      return :deferred
+    else # nil => EOF
+      return pipe.close # nil
+    end while true
+    rescue => e
+      pipe.close
+      raise
+  end
+end

data/lib/rainbows/epoll/response_chunk_pipe.rb

@@ -0,0 +1,18 @@
+# -*- encoding: binary -*-
+# :enddoc:
+#
+class Rainbows::Epoll::ResponseChunkPipe < Rainbows::Epoll::ResponsePipe
+  def tryread
+    @io or return
+
+    case rv = super
+    when String
+      "#{rv.size.to_s(16)}\r\n#{rv}\r\n"
+    when nil
+      close
+      "0\r\n\r\n"
+    else
+      rv
+    end
+  end
+end

data/lib/rainbows/epoll/response_pipe.rb

@@ -0,0 +1,32 @@
+# -*- encoding: binary -*-
+# :enddoc:
+#
+class Rainbows::Epoll::ResponsePipe
+  attr_reader :io
+  alias to_io io
+  RBUF = Rainbows::EvCore::RBUF
+  EP = Rainbows::Epoll::EP
+
+  def initialize(io, client, body)
+    @io, @client, @body = io, client, body
+  end
+
+  def epoll_run
+    return close if @client.closed?
+    @client.stream_pipe(self) or @client.on_deferred_write_complete
+    rescue => e
+      close
+      @client.handle_error(e)
+  end
+
+  def close
+    @io or return
+    EP.delete self
+    @body.respond_to?(:close) and @body.close
+    @io = @body = nil
+  end
+
+  def tryread
+    Kgio.tryread(@io, 16384, RBUF)
+  end
+end

data/lib/rainbows/epoll/server.rb

@@ -0,0 +1,31 @@
+# -*- encoding: binary -*-
+# :enddoc:
+module Rainbows::Epoll::Server
+  @@nr = 0
+  Rainbows::Epoll.nr_clients = lambda { @@nr }
+  IN = SleepyPenguin::Epoll::IN | SleepyPenguin::Epoll::ET
+  MAX = Rainbows.server.worker_connections
+  THRESH = MAX - 1
+  LISTENERS = Rainbows::HttpServer::LISTENERS
+  EP = Rainbows::Epoll::EP
+
+  def self.run
+    LISTENERS.each { |sock| EP.add(sock.extend(self), IN) }
+    Rainbows::Epoll.loop
+  end
+
+  # rearms all listeners when there's a free slot
+  def self.decr
+    THRESH == (@@nr -= 1) and LISTENERS.each { |sock| EP.set(sock, IN) }
+  end
+
+  def epoll_run
+    return EP.delete(self) if @@nr >= MAX
+    while io = kgio_tryaccept
+      @@nr += 1
+      # there's a chance the client never even sees epoll for simple apps
+      io.epoll_once
+      return EP.delete(self) if @@nr >= MAX
+    end
+  end
+end

data/lib/rainbows/error.rb

@@ -7,13 +7,7 @@ module Rainbows::Error
   # if the socket is already closed or broken.  We'll always ensure
   # the socket is closed at the end of this function
   def self.write(io, e)
-    if msg = response(e)
-      if io.respond_to?(:kgio_trywrite)
-        io.kgio_trywrite(msg)
-      else
-        io.write_nonblock(msg)
-      end
-    end
+    msg = response(e) and Kgio.trywrite(io, msg)
     rescue
   end
 
@@ -35,8 +29,6 @@ module Rainbows::Error
     when EOFError, Errno::ECONNRESET, Errno::EPIPE, Errno::EINVAL,
          Errno::EBADF, Errno::ENOTCONN
       # swallow error if client shuts down one end or disconnects
-    when Rainbows::Response416
-      Rainbows::Const::ERROR_416_RESPONSE
     when Unicorn::HttpParserError
       Rainbows::Const::ERROR_400_RESPONSE # try to tell the client they're bad
     when IOError # HttpParserError is an IOError