rainbows 3.2.0 → 3.3.0

data/lib/rainbows/never_block.rb

@@ -6,8 +6,11 @@
 # a streaming "rack.input" but is compatible with everything else
 # EventMachine supports.
 #
+# === :pool_size vs worker_connections
+#
 # In your Rainbows! config block, you may specify a Fiber pool size
 # to limit your application concurrency (without using Rainbows::AppPool)
+# independently of worker_connections.
 #
 #   Rainbows! do
 #     use :NeverBlock, :pool_size => 50
@@ -15,20 +18,14 @@
 #   end
 #
 module Rainbows::NeverBlock
-
   # :stopdoc:
-  DEFAULTS = {
-    :pool_size => 20, # same default size used by NB
-    :backend => :EventMachine, # NeverBlock doesn't support Rev yet
-  }
+  extend Rainbows::PoolSize
 
   # same pool size NB core itself uses
   def self.setup # :nodoc:
-    o = Rainbows::O
-    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"
-    mod = Rainbows.const_get(o[:backend])
+    super
+    Rainbows::O[:backend] ||= :EventMachine # no Cool.io support, yet
+    Rainbows.const_get(Rainbows::O[:backend])
     require "never_block" # require EM first since we need a higher version
   end
 

data/lib/rainbows/pool_size.rb

@@ -0,0 +1,14 @@
+# -*- encoding: binary -*-
+# :stopdoc:
+module Rainbows::PoolSize
+  DEFAULTS = {
+    :pool_size => 50, # same as the default worker_connections
+  }
+
+  def setup
+    o = Rainbows::O
+    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
+end

data/lib/rainbows/process_client.rb

@@ -7,10 +7,11 @@ module Rainbows::ProcessClient
   NULL_IO = Unicorn::HttpRequest::NULL_IO
   RACK_INPUT = Unicorn::HttpRequest::RACK_INPUT
   IC = Unicorn::HttpRequest.input_class
+  Rainbows.config!(self, :client_header_buffer_size)
 
   def process_loop
     @hp = hp = Rainbows::HttpParser.new
-    kgio_read!(16384, buf = hp.buf) or return
+    kgio_read!(CLIENT_HEADER_BUFFER_SIZE, buf = hp.buf) or return
 
     begin # loop
       until env = hp.parse
@@ -46,4 +47,25 @@ module Rainbows::ProcessClient
   def set_input(env, hp)
     env[RACK_INPUT] = 0 == hp.content_length ? NULL_IO : IC.new(self, hp)
   end
+
+  def process_pipeline(env, hp)
+    begin
+      set_input(env, hp)
+      env[REMOTE_ADDR] = kgio_addr
+      status, headers, body = APP.call(env.merge!(RACK_DEFAULTS))
+      if 100 == status.to_i
+        write(EXPECT_100_RESPONSE)
+        env.delete(HTTP_EXPECT)
+        status, headers, body = APP.call(env)
+      end
+      write_response(status, headers, body, alive = hp.next?)
+    end while alive && pipeline_ready(hp)
+    alive or close
+    rescue => e
+      handle_error(e)
+  end
+
+  # override this in subclass/module
+  def pipeline_ready(hp)
+  end
 end

data/lib/rainbows/queue_pool.rb

@@ -5,24 +5,26 @@ require 'thread'
 # Thread pool class based on pulling off a single Ruby Queue.
 # This is NOT used for the ThreadPool class, since that class does not
 # need a userspace Queue.
-class Rainbows::QueuePool < Struct.new(:queue, :threads)
+class Rainbows::QueuePool
+  attr_reader :queue
+
   def initialize(size = 20)
     q = Queue.new
-    self.threads = (1..size).map do
+    @threads = (1..size).map do
       Thread.new do
         while job = q.shift
           yield job
         end
       end
     end
-    self.queue = q
+    @queue = q
   end
 
   def quit!
-    threads.each { |_| queue << nil }
-    threads.delete_if do |t|
+    @threads.each { |_| @queue << nil }
+    @threads.delete_if do |t|
       Rainbows.tick
       t.alive? ? t.join(0.01) : true
-    end until threads.empty?
+    end until @threads.empty?
   end
 end

data/lib/rainbows/response.rb

@@ -6,6 +6,7 @@ module Rainbows::Response
   KeepAlive = "keep-alive"
   Content_Length = "Content-Length".freeze
   Transfer_Encoding = "Transfer-Encoding".freeze
+  Rainbows.config!(self, :copy_stream)
 
   # private file class for IO objects opened by Rainbows! itself (and not
   # the app or middleware)
@@ -14,7 +15,7 @@ module Rainbows::Response
   # called after forking
   def self.setup(klass)
     Kgio.accept_class = Rainbows::Client
-    0 == Rainbows.keepalive_timeout and
+    0 == Rainbows.server.keepalive_timeout and
       Rainbows::HttpParser.keepalive_requests = 0
   end
 
@@ -67,7 +68,7 @@ module Rainbows::Response
     end
 
     # generic response writer, used for most dynamically-generated responses
-    # and also when IO.copy_stream and/or IO#trysendfile is unavailable
+    # and also when copy_stream and/or IO#trysendfile is unavailable
     def write_response(status, headers, body, alive)
       write_headers(status, headers, alive)
       write_body_each(body)
@@ -89,29 +90,29 @@ module Rainbows::Response
     include Sendfile
   end
 
-  if IO.respond_to?(:copy_stream)
+  if COPY_STREAM
     unless IO.method_defined?(:trysendfile)
       module CopyStream
         def write_body_file(body, range)
-          range ? IO.copy_stream(body, self, range[1], range[0]) :
-                  IO.copy_stream(body, self, nil, 0)
+          range ? COPY_STREAM.copy_stream(body, self, range[1], range[0]) :
+                  COPY_STREAM.copy_stream(body, self, nil, 0)
         end
       end
       include CopyStream
     end
 
-    # write_body_stream is an alias for write_body_each if IO.copy_stream
+    # write_body_stream is an alias for write_body_each if copy_stream
     # isn't used or available.
     def write_body_stream(body)
-      IO.copy_stream(io = body_to_io(body), self)
+      COPY_STREAM.copy_stream(io = body_to_io(body), self)
       ensure
         close_if_private(io)
     end
-  else # ! IO.respond_to?(:copy_stream)
+  else # ! COPY_STREAM
     alias write_body_stream write_body_each
-  end  # ! IO.respond_to?(:copy_stream)
+  end  # ! COPY_STREAM
 
-  if IO.method_defined?(:trysendfile) || IO.respond_to?(:copy_stream)
+  if IO.method_defined?(:trysendfile) || COPY_STREAM
     HTTP_RANGE = 'HTTP_RANGE'
     Content_Range = 'Content-Range'.freeze
 
@@ -181,5 +182,5 @@ module Rainbows::Response
       end
     end
     include ToPath
-  end # IO.respond_to?(:copy_stream) || IO.method_defined?(:trysendfile)
+  end # COPY_STREAM || IO.method_defined?(:trysendfile)
 end

data/lib/rainbows/revactor.rb

@@ -3,10 +3,14 @@ require 'revactor'
 require 'fcntl'
 Revactor::VERSION >= '0.1.5' or abort 'revactor 0.1.5 is required'
 
-# Enables use of the Actor model through
-# {Revactor}[http://revactor.org] under Ruby 1.9.  It spawns one
-# long-lived Actor for every listen socket in the process and spawns a
-# new Actor for every client connection accept()-ed.
+# Enables use of the Actor model through {Revactor}[http://revactor.org]
+# under Ruby 1.9.
+#
+# \Revactor dormant upstream, so the use of this is NOT recommended for
+# new applications.
+#
+# It spawns one long-lived Actor for every listen socket in the process
+# and spawns a new Actor for every client connection accept()-ed.
 # +worker_connections+ will limit the number of client Actors we have
 # running at any one time.
 #
@@ -18,6 +22,9 @@ Revactor::VERSION >= '0.1.5' or abort 'revactor 0.1.5 is required'
 # in the application using this model should be implemented using the
 # \Revactor library as well, to take advantage of the networking
 # concurrency features this model provides.
+#
+# === RubyGem Requirements
+# * revactor 0.1.5 or later
 module Rainbows::Revactor
   autoload :Client, 'rainbows/revactor/client'
   autoload :Proxy, 'rainbows/revactor/proxy'
@@ -34,8 +41,8 @@ module Rainbows::Revactor
     limit = worker_connections
     actor_exit = Case[:exit, Actor, Object]
 
-    revactorize_listeners.each do |l, close, accept|
-      Actor.spawn(l, close, accept) do |l, close, accept|
+    revactorize_listeners.each do |l,close,accept|
+      Actor.spawn do
         Actor.current.trap_exit = true
         l.controller = l.instance_variable_set(:@receiver, Actor.current)
         begin
@@ -73,7 +80,7 @@ module Rainbows::Revactor
       # ignore, let another worker process take it
   end
 
-  def revactorize_listeners
+  def revactorize_listeners #:nodoc:
     LISTENERS.map do |s|
       case s
       when TCPServer

data/lib/rainbows/revactor/client.rb

@@ -4,8 +4,8 @@ require 'fcntl'
 class Rainbows::Revactor::Client
   autoload :TeeSocket, 'rainbows/revactor/client/tee_socket'
   RD_ARGS = {}
-  Rainbows.keepalive_timeout > 0 and
-    RD_ARGS[:timeout] = Rainbows.keepalive_timeout
+  Rainbows.server.keepalive_timeout > 0 and
+    RD_ARGS[:timeout] = Rainbows.server.keepalive_timeout
   attr_reader :kgio_addr
 
   def initialize(client)

data/lib/rainbows/stream_file.rb

@@ -5,10 +5,17 @@
 # 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, :count, :to_io, :body)
+class Rainbows::StreamFile
+  attr_reader :to_io
+  attr_accessor :offset, :count
+
+  def initialize(offset, count, io, body)
+    @offset, @count, @to_io, @body = offset, count, io, body
+  end
+
   def close
-    body.close if body.respond_to?(:close)
-    to_io.close unless to_io.closed?
-    self.to_io = nil
+    @body.close if @body.respond_to?(:close)
+    @to_io.close unless @to_io.closed?
+    @to_io = nil
   end
 end

data/lib/rainbows/thread_pool.rb

@@ -1,24 +1,21 @@
 # -*- encoding: binary -*-
 
 # Implements a worker thread pool model.  This is suited for platforms
-# like Ruby 1.9, where the cost of dynamically spawning a new thread
-# for every new client connection is higher than with the ThreadSpawn
-# model.
+# like Ruby 1.9, where the cost of dynamically spawning a new thread for
+# every new client connection is higher than with the ThreadSpawn model,
+# but the cost of an idle thread is low (e.g. NPTL under Linux).
 #
-# This model should provide a high level of compatibility with all
-# Ruby implementations, and most libraries and applications.
-# Applications running under this model should be thread-safe
-# but not necessarily reentrant.
+# This model should provide a high level of compatibility with all Ruby
+# implementations, and most libraries and applications.  Applications
+# running under this model should be thread-safe but not necessarily
+# reentrant.
 #
-# Applications using this model are required to be thread-safe.
-# Threads are never spawned dynamically under this model.  If you're
-# connecting to external services and need to perform DNS lookups,
-# consider using the "resolv-replace" library which replaces parts of
-# the core Socket package with concurrent DNS lookup capabilities.
+# Applications using this model are required to be thread-safe.  Threads
+# are never spawned dynamically under this model.
 #
-# This model probably less suited for many slow clients than the
-# others and thus a lower +worker_connections+ setting is recommended.
-
+# If you're using green threads (MRI 1.8) and need to perform DNS lookups,
+# consider using the "resolv-replace" library which replaces parts of the
+# core Socket package with concurrent DNS lookup capabilities.
 module Rainbows::ThreadPool
   include Rainbows::Base
 
@@ -62,17 +59,4 @@ module Rainbows::ThreadPool
       Rainbows::Error.listen_loop(e)
     end while Rainbows.alive
   end
-
-  def join_threads(threads) # :nodoc:
-    Rainbows.quit!
-    threads.delete_if do |thr|
-      Rainbows.tick
-      begin
-        thr.run
-        thr.join(0.01)
-      rescue
-        true
-      end
-    end until threads.empty?
-  end
 end

data/lib/rainbows/thread_spawn.rb

@@ -2,18 +2,19 @@
 require 'thread'
 
 # Spawns a new thread for every client connection we accept().  This
-# model is recommended for platforms like Ruby 1.8 where spawning new
-# threads is inexpensive.
+# model is recommended for platforms like Ruby (MRI) 1.8 where spawning
+# new threads is inexpensive, but still seems to work well enough with
+# good native threading implementations such as NPTL under Linux on
+# Ruby (MRI/YARV) 1.9
 #
-# This model should provide a high level of compatibility with all
-# Ruby implementations, and most libraries and applications.
-# Applications running under this model should be thread-safe
-# but not necessarily reentrant.
+# This model should provide a high level of compatibility with all Ruby
+# implementations, and most libraries and applications.  Applications
+# running under this model should be thread-safe but not necessarily
+# reentrant.
 #
-# If you're connecting to external services and need to perform DNS
-# lookups, consider using the "resolv-replace" library which replaces
-# parts of the core Socket package with concurrent DNS lookup
-# capabilities
+# If you're using green threads (MRI 1.8) and need to perform DNS lookups,
+# consider using the "resolv-replace" library which replaces parts of the
+# core Socket package with concurrent DNS lookup capabilities.
 
 module Rainbows::ThreadSpawn
   include Rainbows::Base
@@ -24,12 +25,12 @@ module Rainbows::ThreadSpawn
     limit = worker_connections
     nr = 0
     LISTENERS.each do |l|
-      klass.new(l) do |l|
+      klass.new do
         begin
           if lock.synchronize { nr >= limit }
             worker_yield
-          elsif c = l.kgio_accept
-            klass.new(c) do |c|
+          elsif client = l.kgio_accept
+            klass.new(client) do |c|
               begin
                 lock.synchronize { nr += 1 }
                 c.process_loop

data/lib/rainbows/thread_timeout.rb

@@ -29,14 +29,35 @@ require 'thread'
 #
 # Timed-out requests will cause this middleware to return with a
 # "408 Request Timeout" response.
-
+#
+# == Caveats
+#
+# Badly-written C extensions may not be timed out.  Audit and fix
+# (or remove) those extensions before relying on this module.
+#
+# Do NOT, under any circumstances nest and load this in
+# the same middleware stack.  You may load this in parallel in the
+# same process completely independent middleware stacks, but DO NOT
+# load this twice so it nests.  Things will break!
+#
+# This will behave badly if system time is changed since Ruby
+# does not expose a monotonic clock for users, so don't change
+# the system time while this is running.  All servers should be
+# running ntpd anyways.
 class Rainbows::ThreadTimeout
 
   # :stopdoc:
-  class ExecutionExpired < Exception
-  end
+  #
+  # we subclass Exception to get rid of normal StandardError rescues
+  # in app-level code.  timeout.rb does something similar
+  ExecutionExpired = Class.new(Exception)
+
+  # The MRI 1.8 won't be usable in January 2038, we'll raise this
+  # when we eventually drop support for 1.8 (before 2038, hopefully)
+  NEVER = Time.at(0x7fffffff)
 
   def initialize(app, opts)
+    # @timeout must be Numeric since we add this to Time
     @timeout = opts[:timeout]
     Numeric === @timeout or
       raise TypeError, "timeout=#{@timeout.inspect} is not numeric"
@@ -44,56 +65,123 @@ class Rainbows::ThreadTimeout
     if @threshold = opts[:threshold]
       Integer === @threshold or
         raise TypeError, "threshold=#{@threshold.inspect} is not an integer"
-      @threshold == 0 and
-        raise ArgumentError, "threshold=0 does not make sense"
-      @threshold < 0 and
-        @threshold += Rainbows.server.worker_connections
+      @threshold == 0 and raise ArgumentError, "threshold=0 does not make sense"
+      @threshold < 0 and @threshold += Rainbows.server.worker_connections
     end
     @app = app
+
+    # This is the main datastructure for communicating Threads eligible
+    # for expiration to the watchdog thread.  If the eligible thread
+    # completes its job before its expiration time, it will delete itself
+    # @active.  If the watchdog thread notices the thread is timed out,
+    # the watchdog thread will delete the thread from this hash as it
+    # raises the exception.
+    #
+    # key: Thread to be timed out
+    # value: Time of expiration
     @active = {}
+
+    # Protects all access to @active.  It is important since it also limits
+    # safe points for asynchronously raising exceptions.
     @lock = Mutex.new
+
+    # There is one long-running watchdog thread that watches @active and
+    # kills threads that have been running too long
+    # see start_watchdog
+    @watchdog = nil
   end
 
+  # entry point for Rack middleware
   def call(env)
-    @lock.synchronize do
-      start_watchdog unless @watchdog
-      @active[Thread.current] = Time.now + @timeout
-    end
+    # Once we have this lock, we ensure two things:
+    # 1) there is only one watchdog thread started
+    # 2) we can't be killed once we have this lock, it's unlikely
+    #    to happen unless @timeout is really low and the machine
+    #    is very slow.
+    @lock.lock
+
+    # we're dead if anything in the next two lines raises, but it's
+    # highly unlikely that they will, and anything such as NoMemoryError
+    # is hopeless and we might as well just die anyways.
+    # initialize guarantees @timeout will be Numeric
+    start_watchdog(env) unless @watchdog
+    @active[Thread.current] = Time.now + @timeout
+
     begin
+      # It is important to unlock inside this begin block
+      # Mutex#unlock really can't fail here since we did a successful
+      # Mutex#lock before
+      @lock.unlock
+
+      # Once the Mutex was unlocked, we're open to Thread#raise from
+      # the watchdog process.  This is the main place we expect to receive
+      # Thread#raise.  @app is of course the next layer of the Rack
+      # application stack
       @app.call(env)
     ensure
+      # I's still possible to receive a Thread#raise here from
+      # the watchdog, but that's alright, the "rescue ExecutionExpired"
+      # line will catch that.
       @lock.synchronize { @active.delete(Thread.current) }
+      # Thread#raise no longer possible here
     end
     rescue ExecutionExpired
+      # If we got here, it's because the watchdog thread raised an exception
+      # here to kill us.  The watchdog uses @active.delete_if with a lock,
+      # so we guaranteed it's
       [ 408, { 'Content-Type' => 'text/plain', 'Content-Length' => '0' }, [] ]
   end
 
-  def start_watchdog
-    @watchdog = Thread.new do
+  # The watchdog thread is the one that does the job of killing threads
+  # that have expired.
+  def start_watchdog(env)
+    @watchdog = Thread.new(env["rack.logger"]) do |logger|
       begin
-        if next_wake = @lock.synchronize { @active.values }.min
-          next_wake -= Time.now
-
-          # because of the lack of GVL-releasing syscalls in this branch
-          # of the thread loop, we need Thread.pass to ensure other threads
-          # get scheduled appropriately under 1.9.  This is likely a threading
-          # bug in 1.9 that warrants further investigation when we're in a
-          # better mood.
-          next_wake > 0 ? sleep(next_wake) : Thread.pass
-        else
-          sleep(@timeout)
+        if @threshold
+          # Hash#size is atomic in MRI 1.8 and 1.9 and we
+          # expect that from other implementations.
+          #
+          # Even without a memory barrier, sleep(@timeout) vs
+          # sleep(@timeout - time-for-SMP-to-synchronize-a-word)
+          # is too trivial to worry about here.
+          sleep(@timeout) while @active.size < @threshold
         end
 
-        # "active.size" is atomic in MRI 1.8 and 1.9
-        next if @threshold && @active.size < @threshold
+        next_expiry = NEVER
 
-        now = Time.now
+        # We always lock access to @active, so we can't kill threads
+        # that are about to release themselves from the eye of the
+        # watchdog thread.
         @lock.synchronize do
-          @active.delete_if do |thread, time|
-            now >= time and thread.raise(ExecutionExpired).nil?
+          now = Time.now
+          @active.delete_if do |thread, expire_at|
+            # We also use this loop to get the maximum possible time to
+            # sleep for if we're not killing the thread.
+            if expire_at > now
+              next_expiry = expire_at if next_expiry > expire_at
+              false
+            else
+              # Terminate execution and delete this from the @active
+              thread.raise(ExecutionExpired)
+              true
+            end
           end
         end
-      end while true
+
+        # We always try to sleep as long as possible to avoid consuming
+        # resources from the app.  So that's the user-configured @timeout
+        # value.
+        if next_expiry == NEVER
+          sleep(@timeout)
+        else
+          # sleep until the next known thread is about to expire.
+          sec = next_expiry - Time.now
+          sec > 0.0 ? sleep(sec) : Thread.pass # give other threads a chance
+        end
+      rescue => e
+        # just in case
+        logger.error e
+      end while true # we run this forever
     end
   end
   # :startdoc: