rainbows 0.97.0 → 1.0.0pre1

data/lib/rainbows/app_pool.rb

@@ -2,105 +2,101 @@
 
 require 'thread'
 
-module Rainbows
+# Rack middleware to limit application-level concurrency independently
+# of network conncurrency in \Rainbows!   Since the +worker_connections+
+# option in \Rainbows! is only intended to limit the number of
+# simultaneous clients, this middleware may be used to limit the
+# number of concurrent application dispatches independently of
+# concurrent clients.
+#
+# Instead of using M:N concurrency in \Rainbows!, this middleware
+# allows M:N:P concurrency where +P+ is the AppPool +:size+ while
+# +M+ remains the number of +worker_processes+ and +N+ remains the
+# number of +worker_connections+.
+#
+#   rainbows master
+#    \_ rainbows worker[0]
+#    |  \_ client[0,0]------\      ___app[0]
+#    |  \_ client[0,1]-------\    /___app[1]
+#    |  \_ client[0,2]-------->--<       ...
+#    |  ...                __/    `---app[P]
+#    |  \_ client[0,N]----/
+#    \_ rainbows worker[1]
+#    |  \_ client[1,0]------\      ___app[0]
+#    |  \_ client[1,1]-------\    /___app[1]
+#    |  \_ client[1,2]-------->--<       ...
+#    |  ...                __/    `---app[P]
+#    |  \_ client[1,N]----/
+#    \_ rainbows worker[M]
+#       \_ client[M,0]------\      ___app[0]
+#       \_ client[M,1]-------\    /___app[1]
+#       \_ client[M,2]-------->--<       ...
+#       ...                __/    `---app[P]
+#       \_ client[M,N]----/
+#
+# AppPool should be used if you want to enforce a lower value of +P+
+# than +N+.
+#
+# AppPool has no effect on the Rev or EventMachine concurrency models
+# as those are single-threaded/single-instance as far as application
+# concurrency goes.  In other words, +P+ is always +one+ when using
+# Rev or EventMachine.  As of \Rainbows! 0.7.0, it is safe to use with
+# Revactor and the new FiberSpawn and FiberPool concurrency models.
+#
+# Since this is Rack middleware, you may load this in your Rack
+# config.ru file and even use it in threaded servers other than
+# \Rainbows!
+#
+#   use Rainbows::AppPool, :size => 30
+#   map "/lobster" do
+#     run Rack::Lobster.new
+#   end
+#
+# You may to load this earlier or later in your middleware chain
+# depending on the concurrency/copy-friendliness of your middleware(s).
+class Rainbows::AppPool < Struct.new(:pool, :re)
 
-  # Rack middleware to limit application-level concurrency independently
-  # of network conncurrency in \Rainbows!   Since the +worker_connections+
-  # option in \Rainbows! is only intended to limit the number of
-  # simultaneous clients, this middleware may be used to limit the
-  # number of concurrent application dispatches independently of
-  # concurrent clients.
-  #
-  # Instead of using M:N concurrency in \Rainbows!, this middleware
-  # allows M:N:P concurrency where +P+ is the AppPool +:size+ while
-  # +M+ remains the number of +worker_processes+ and +N+ remains the
-  # number of +worker_connections+.
-  #
-  #   rainbows master
-  #    \_ rainbows worker[0]
-  #    |  \_ client[0,0]------\      ___app[0]
-  #    |  \_ client[0,1]-------\    /___app[1]
-  #    |  \_ client[0,2]-------->--<       ...
-  #    |  ...                __/    `---app[P]
-  #    |  \_ client[0,N]----/
-  #    \_ rainbows worker[1]
-  #    |  \_ client[1,0]------\      ___app[0]
-  #    |  \_ client[1,1]-------\    /___app[1]
-  #    |  \_ client[1,2]-------->--<       ...
-  #    |  ...                __/    `---app[P]
-  #    |  \_ client[1,N]----/
-  #    \_ rainbows worker[M]
-  #       \_ client[M,0]------\      ___app[0]
-  #       \_ client[M,1]-------\    /___app[1]
-  #       \_ client[M,2]-------->--<       ...
-  #       ...                __/    `---app[P]
-  #       \_ client[M,N]----/
-  #
-  # AppPool should be used if you want to enforce a lower value of +P+
-  # than +N+.
-  #
-  # AppPool has no effect on the Rev or EventMachine concurrency models
-  # as those are single-threaded/single-instance as far as application
-  # concurrency goes.  In other words, +P+ is always +one+ when using
-  # Rev or EventMachine.  As of \Rainbows! 0.7.0, it is safe to use with
-  # Revactor and the new FiberSpawn and FiberPool concurrency models.
-  #
-  # Since this is Rack middleware, you may load this in your Rack
-  # config.ru file and even use it in threaded servers other than
-  # \Rainbows!
-  #
-  #   use Rainbows::AppPool, :size => 30
-  #   map "/lobster" do
-  #     run Rack::Lobster.new
-  #   end
-  #
-  # You may to load this earlier or later in your middleware chain
-  # depending on the concurrency/copy-friendliness of your middleware(s).
-
-  class AppPool < Struct.new(:pool, :re)
-
-    # +opt+ is a hash, +:size+ is the size of the pool (default: 6)
-    # meaning you can have up to 6 concurrent instances of +app+
-    # within one \Rainbows! worker process.  We support various
-    # methods of the +:copy+ option: +dup+, +clone+, +deep+ and +none+.
-    # Depending on your +app+, one of these options should be set.
-    # The default +:copy+ is +:dup+ as is commonly seen in existing
-    # Rack middleware.
-    def initialize(app, opt = {})
-      self.pool = Queue.new
-      (1...(opt[:size] || 6)).each do
-        pool << case (opt[:copy] || :dup)
-        when :none then app
-        when :dup then app.dup
-        when :clone then app.clone
-        when :deep then Marshal.load(Marshal.dump(app)) # unlikely...
-        else
-          raise ArgumentError, "unsupported copy method: #{opt[:copy].inspect}"
-        end
+  # +opt+ is a hash, +:size+ is the size of the pool (default: 6)
+  # meaning you can have up to 6 concurrent instances of +app+
+  # within one \Rainbows! worker process.  We support various
+  # methods of the +:copy+ option: +dup+, +clone+, +deep+ and +none+.
+  # Depending on your +app+, one of these options should be set.
+  # The default +:copy+ is +:dup+ as is commonly seen in existing
+  # Rack middleware.
+  def initialize(app, opt = {})
+    self.pool = Queue.new
+    (1...(opt[:size] || 6)).each do
+      pool << case (opt[:copy] || :dup)
+      when :none then app
+      when :dup then app.dup
+      when :clone then app.clone
+      when :deep then Marshal.load(Marshal.dump(app)) # unlikely...
+      else
+        raise ArgumentError, "unsupported copy method: #{opt[:copy].inspect}"
       end
-      pool << app # the original
     end
+    pool << app # the original
+  end
 
-    # Rack application endpoint, +env+ is the Rack environment
-    def call(env) # :nodoc:
+  # Rack application endpoint, +env+ is the Rack environment
+  def call(env) # :nodoc:
 
-      # we have to do this check at call time (and not initialize)
-      # because of preload_app=true and models being changeable with SIGHUP
-      # fortunately this is safe for all the reentrant (but not multithreaded)
-      # classes that depend on it and a safe no-op for multithreaded
-      # concurrency models
-      self.re ||= begin
-        case env["rainbows.model"]
-        when :FiberSpawn, :FiberPool, :Revactor, :NeverBlock, :RevFiberSpawn
-          self.pool = Rainbows::Fiber::Queue.new(pool)
-        end
-        true
+    # we have to do this check at call time (and not initialize)
+    # because of preload_app=true and models being changeable with SIGHUP
+    # fortunately this is safe for all the reentrant (but not multithreaded)
+    # classes that depend on it and a safe no-op for multithreaded
+    # concurrency models
+    self.re ||= begin
+      case env["rainbows.model"]
+      when :FiberSpawn, :FiberPool, :Revactor, :NeverBlock, :RevFiberSpawn
+        self.pool = Rainbows::Fiber::Queue.new(pool)
       end
-
-      app = pool.shift
-      app.call(env)
-      ensure
-        pool << app
+      true
     end
+
+    app = pool.shift
+    app.call(env)
+    ensure
+      pool << app
   end
 end

data/lib/rainbows/base.rb

@@ -8,14 +8,10 @@
 module Rainbows::Base
 
   # :stopdoc:
-  include Rainbows::Const
-  include Rainbows::Response
+  include Rainbows::ProcessClient
 
   # shortcuts...
   G = Rainbows::G
-  NULL_IO = Unicorn::HttpRequest::NULL_IO
-  TeeInput = Rainbows::TeeInput
-  HttpParser = Unicorn::HttpParser
 
   # this method is called by all current concurrency models
   def init_worker_process(worker) # :nodoc:
@@ -24,11 +20,8 @@ module Rainbows::Base
     Rainbows::MaxBody.setup
     G.tmp = worker.tmp
 
-    # avoid spurious wakeups and blocking-accept() with 1.8 green threads
-    if ! defined?(RUBY_ENGINE) && RUBY_VERSION.to_f < 1.9
-      require "io/nonblock"
-      Rainbows::HttpServer::LISTENERS.each { |l| l.nonblock = true }
-    end
+    listeners = Rainbows::HttpServer::LISTENERS
+    Rainbows::HttpServer::IO_PURGATORY.concat(listeners)
 
     # we're don't use the self-pipe mechanism in the Rainbows! worker
     # since we don't defer reopening logs
@@ -36,60 +29,10 @@ module Rainbows::Base
     trap(:USR1) { reopen_worker_logs(worker.nr) }
     trap(:QUIT) { G.quit! }
     [:TERM, :INT].each { |sig| trap(sig) { exit!(0) } } # instant shutdown
+    Rainbows::ProcessClient.const_set(:APP, G.server.app)
     logger.info "Rainbows! #@use worker_connections=#@worker_connections"
   end
 
-  def wait_headers_readable(client)  # :nodoc:
-    IO.select([client], nil, nil, G.kato)
-  end
-
-  # once a client is accepted, it is processed in its entirety here
-  # in 3 easy steps: read request, call app, write app response
-  # this is used by synchronous concurrency models
-  #   Base, ThreadSpawn, ThreadPool
-  def process_client(client) # :nodoc:
-    buf = client.readpartial(CHUNK_SIZE) # accept filters protect us here
-    hp = HttpParser.new
-    env = {}
-    remote_addr = Rainbows.addr(client)
-
-    begin # loop
-      until hp.headers(env, buf)
-        wait_headers_readable(client) or return
-        buf << client.readpartial(CHUNK_SIZE)
-      end
-
-      env[CLIENT_IO] = client
-      env[RACK_INPUT] = 0 == hp.content_length ?
-                        NULL_IO : TeeInput.new(client, env, hp, buf)
-      env[REMOTE_ADDR] = remote_addr
-      status, headers, body = app.call(env.update(RACK_DEFAULTS))
-
-      if 100 == status.to_i
-        client.write(EXPECT_100_RESPONSE)
-        env.delete(HTTP_EXPECT)
-        status, headers, body = app.call(env)
-      end
-
-      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?
-  # if we get any error, try to write something back to the client
-  # assuming we haven't closed the socket, but don't get hung up
-  # if the socket is already closed or broken.  We'll always ensure
-  # the socket is closed at the end of this function
-  rescue => e
-    Rainbows::Error.write(client, e)
-  ensure
-    client.close unless client.closed?
-  end
-
   def self.included(klass) # :nodoc:
     klass.const_set :LISTENERS, Rainbows::HttpServer::LISTENERS
     klass.const_set :G, Rainbows::G

data/lib/rainbows/client.rb

@@ -0,0 +1,9 @@
+# -*- encoding: binary -*-
+# :enddoc:
+
+require 'rainbows/read_timeout'
+
+class Rainbows::Client < Kgio::Socket
+  include Rainbows::ReadTimeout
+end
+Kgio.accept_class = Rainbows::Client

data/lib/rainbows/configurator.rb

@@ -1,46 +1,44 @@
 # -*- encoding: binary -*-
-module Rainbows
 
-  # This module adds \Rainbows! to the
-  # {Unicorn::Configurator}[http://unicorn.bogomips.org/Unicorn/Configurator.html]
-  module Configurator
-
-    # configures \Rainbows! with a given concurrency model to +use+ and
-    # a +worker_connections+ upper-bound.  This method may be called
-    # inside a Unicorn/\Rainbows! configuration file:
-    #
-    #   Rainbows! do
-    #     use :ThreadSpawn # concurrency model to use
-    #     worker_connections 400
-    #     keepalive_timeout 0 # zero disables keepalives entirely
-    #     client_max_body_size 5*1024*1024 # 5 megabytes
-    #   end
-    #
-    #   # the rest of the Unicorn configuration
-    #   worker_processes 8
-    #
-    # See the documentation for the respective Revactor, ThreadSpawn,
-    # and ThreadPool classes for descriptions and recommendations for
-    # each of them.  The total number of clients we're able to serve is
-    # +worker_processes+ * +worker_connections+, so in the above example
-    # we can serve 8 * 400 = 3200 clients concurrently.
-    #
-    # The default is +keepalive_timeout+ is 5 seconds, which should be
-    # enough under most conditions for browsers to render the page and
-    # start retrieving extra elements for.  Increasing this beyond 5
-    # seconds is not recommended.  Zero disables keepalive entirely
-    # (but pipelining fully-formed requests is still works).
-    #
-    # The default +client_max_body_size+ is 1 megabyte (1024 * 1024 bytes),
-    # setting this to +nil+ will disable body size checks and allow any
-    # size to be specified.
-    def Rainbows!(&block)
-      block_given? or raise ArgumentError, "Rainbows! requires a block"
-      HttpServer.setup(block)
-    end
+# This module adds \Rainbows! to the
+# {Unicorn::Configurator}[http://unicorn.bogomips.org/Unicorn/Configurator.html]
+module Rainbows::Configurator
 
+  # configures \Rainbows! with a given concurrency model to +use+ and
+  # a +worker_connections+ upper-bound.  This method may be called
+  # inside a Unicorn/\Rainbows! configuration file:
+  #
+  #   Rainbows! do
+  #     use :ThreadSpawn # concurrency model to use
+  #     worker_connections 400
+  #     keepalive_timeout 0 # zero disables keepalives entirely
+  #     client_max_body_size 5*1024*1024 # 5 megabytes
+  #   end
+  #
+  #   # the rest of the Unicorn configuration
+  #   worker_processes 8
+  #
+  # See the documentation for the respective Revactor, ThreadSpawn,
+  # and ThreadPool classes for descriptions and recommendations for
+  # each of them.  The total number of clients we're able to serve is
+  # +worker_processes+ * +worker_connections+, so in the above example
+  # we can serve 8 * 400 = 3200 clients concurrently.
+  #
+  # The default is +keepalive_timeout+ is 5 seconds, which should be
+  # enough under most conditions for browsers to render the page and
+  # start retrieving extra elements for.  Increasing this beyond 5
+  # seconds is not recommended.  Zero disables keepalive entirely
+  # (but pipelining fully-formed requests is still works).
+  #
+  # The default +client_max_body_size+ is 1 megabyte (1024 * 1024 bytes),
+  # setting this to +nil+ will disable body size checks and allow any
+  # size to be specified.
+  def Rainbows!(&block)
+    block_given? or raise ArgumentError, "Rainbows! requires a block"
+    Rainbows::HttpServer.setup(block)
   end
 end
 
+# :enddoc:
 # inject the Rainbows! method into Unicorn::Configurator
-Unicorn::Configurator.class_eval { include Rainbows::Configurator }
+Unicorn::Configurator.__send__(:include, Rainbows::Configurator)

data/lib/rainbows/const.rb

@@ -1,28 +1,28 @@
 # -*- encoding: binary -*-
 # :enddoc:
-module Rainbows
+module Rainbows::Const
 
-  module Const
-    RAINBOWS_VERSION = '0.97.0'
+  RAINBOWS_VERSION = '1.0.0pre1'
 
-    include Unicorn::Const
+  include Unicorn::Const
 
-    RACK_DEFAULTS = Unicorn::HttpRequest::DEFAULTS.update({
-      "SERVER_SOFTWARE" => "Rainbows! #{RAINBOWS_VERSION}",
+  RACK_DEFAULTS = Unicorn::HttpRequest::DEFAULTS.update({
+    "SERVER_SOFTWARE" => "Rainbows! #{RAINBOWS_VERSION}",
 
-      # using the Rev model, we'll automatically chunk pipe and socket objects
-      # if they're the response body.  Unset by default.
-      # "rainbows.autochunk" => false,
-    })
+    # using the Rev model, we'll automatically chunk pipe and socket objects
+    # if they're the response body.  Unset by default.
+    # "rainbows.autochunk" => false,
+  })
 
-    # client IO object that supports reading and writing directly
-    # without filtering it through the HTTP chunk parser.
-    # Maybe we can get this renamed to "rack.io" if it becomes part
-    # of the official spec, but for now it is "hack.io"
-    CLIENT_IO = "hack.io".freeze
+  # client IO object that supports reading and writing directly
+  # without filtering it through the HTTP chunk parser.
+  # Maybe we can get this renamed to "rack.io" if it becomes part
+  # of the official spec, but for now it is "hack.io"
+  CLIENT_IO = "hack.io".freeze
 
-    ERROR_413_RESPONSE = "HTTP/1.1 413 Request Entity Too Large\r\n\r\n"
-    ERROR_416_RESPONSE = "HTTP/1.1 416 Requested Range Not Satisfiable\r\n\r\n"
+  ERROR_413_RESPONSE = "HTTP/1.1 413 Request Entity Too Large\r\n\r\n"
+  ERROR_416_RESPONSE = "HTTP/1.1 416 Requested Range Not Satisfiable\r\n\r\n"
 
-  end
+  RACK_INPUT = Unicorn::HttpRequest::RACK_INPUT
+  REMOTE_ADDR = Unicorn::HttpRequest::REMOTE_ADDR
 end

data/lib/rainbows/dev_fd_response.rb

@@ -54,7 +54,8 @@ class Rainbows::DevFdResponse < Struct.new(:app)
       # we need to make sure our pipe output is Fiber-compatible
       case env["rainbows.model"]
       when :FiberSpawn, :FiberPool, :RevFiberSpawn
-        io = Rainbows::Fiber::IO.new(io,::Fiber.current)
+        io.respond_to?(:wait_readable) or
+          io = Rainbows::Fiber::IO.new(io)
       when :Revactor
         io = Rainbows::Revactor::Proxy.new(io)
       end

data/lib/rainbows/error.rb

@@ -1,48 +1,50 @@
 # -*- encoding: binary -*-
 # :enddoc:
-module Rainbows
+module Rainbows::Error
 
-  class Error
-    class << self
+  G = Rainbows::G
 
-      # if we get any error, try to write something back to the client
-      # assuming we haven't closed the socket, but don't get hung up
-      # if the socket is already closed or broken.  We'll always ensure
-      # the socket is closed at the end of this function
-      def write(io, e)
-        msg = Error.response(e) and io.write_nonblock(msg)
-        rescue
-      end
-
-      def app(e)
-        G.server.logger.error "app error: #{e.inspect}"
-        G.server.logger.error e.backtrace.join("\n")
-        rescue
+  # if we get any error, try to write something back to the client
+  # assuming we haven't closed the socket, but don't get hung up
+  # 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
+    rescue
+  end
 
-      def listen_loop(e)
-        G.alive or return
-        G.server.logger.error "listen loop error: #{e.inspect}."
-        G.server.logger.error e.backtrace.join("\n")
-        rescue
-      end
+  def self.app(e)
+    G.server.logger.error "app error: #{e.inspect}"
+    G.server.logger.error e.backtrace.join("\n")
+    rescue
+  end
 
-      def response(e)
-        case e
-        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
-          Const::ERROR_416_RESPONSE
-        when Unicorn::HttpParserError
-          Const::ERROR_400_RESPONSE # try to tell the client they're bad
-        when IOError # HttpParserError is an IOError
-        else
-          app(e)
-          Const::ERROR_500_RESPONSE
-        end
-      end
+  def self.listen_loop(e)
+    G.alive or return
+    G.server.logger.error "listen loop error: #{e.inspect}."
+    G.server.logger.error e.backtrace.join("\n")
+    rescue
+  end
 
+  def self.response(e)
+    case e
+    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
+    else
+      app(e)
+      Rainbows::Const::ERROR_500_RESPONSE
     end
   end
 end