rainbows 2.0.1 → 2.1.0

data/lib/rainbows/thread_timeout.rb

@@ -30,61 +30,67 @@ require 'thread'
 # Timed-out requests will cause this middleware to return with a
 # "408 Request Timeout" response.
 
-class Rainbows::ThreadTimeout < Struct.new(:app, :timeout,
-                                           :threshold, :watchdog,
-                                           :active, :lock)
+class Rainbows::ThreadTimeout
 
   # :stopdoc:
-  class ExecutionExpired < ::Exception
+  class ExecutionExpired < Exception
   end
 
   def initialize(app, opts)
-    timeout = opts[:timeout]
-    Numeric === timeout or
-      raise TypeError, "timeout=#{timeout.inspect} is not numeric"
+    @timeout = opts[:timeout]
+    Numeric === @timeout or
+      raise TypeError, "timeout=#{@timeout.inspect} is not numeric"
 
-    if threshold = opts[:threshold]
-      Integer === threshold or
-        raise TypeError, "threshold=#{threshold.inspect} is not an integer"
-      threshold == 0 and
+    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::G.server.worker_connections
+      @threshold < 0 and
+        @threshold += Rainbows::G.server.worker_connections
     end
-    super(app, timeout, threshold, nil, {}, Mutex.new)
+    @app = app
+    @active = {}
+    @lock = Mutex.new
   end
 
   def call(env)
-    lock.synchronize do
-      start_watchdog unless watchdog
-      active[Thread.current] = Time.now + timeout
+    @lock.synchronize do
+      start_watchdog unless @watchdog
+      @active[Thread.current] = Time.now + @timeout
     end
     begin
-      app.call(env)
+      @app.call(env)
     ensure
-      lock.synchronize { active.delete(Thread.current) }
+      @lock.synchronize { @active.delete(Thread.current) }
     end
     rescue ExecutionExpired
       [ 408, { 'Content-Type' => 'text/plain', 'Content-Length' => '0' }, [] ]
   end
 
   def start_watchdog
-    self.watchdog = Thread.new do
+    @watchdog = Thread.new do
       begin
-        if next_wake = lock.synchronize { active.values }.min
+        if next_wake = @lock.synchronize { @active.values }.min
           next_wake -= Time.now
-          sleep(next_wake) if next_wake > 0
+
+          # 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)
+          sleep(@timeout)
         end
 
         # "active.size" is atomic in MRI 1.8 and 1.9
-        next if threshold && active.size < threshold
+        next if @threshold && @active.size < @threshold
 
         now = Time.now
-        lock.synchronize do
-          active.delete_if do |thread, time|
-            time >= now and thread.raise(ExecutionExpired).nil?
+        @lock.synchronize do
+          @active.delete_if do |thread, time|
+            now >= time and thread.raise(ExecutionExpired).nil?
           end
         end
       end while true

data/lib/rainbows/timed_read.rb

@@ -3,6 +3,10 @@
 module Rainbows::TimedRead
   G = Rainbows::G # :nodoc:
 
+  def read_expire
+    Time.now + G.kato
+  end
+
   def kgio_wait_readable
     IO.select([self], nil, nil, G.kato)
   end
@@ -14,7 +18,7 @@ module Rainbows::TimedRead
       case rv = kgio_tryread(16384, buf)
       when :wait_readable
         return if expire && expire < Time.now
-        expire ||= Time.now + G.kato
+        expire ||= read_expire
         kgio_wait_readable
       else
         return rv

data/lib/rainbows/worker_yield.rb

@@ -0,0 +1,16 @@
+# -*- encoding: binary -*-
+# :enddoc:
+module Rainbows::WorkerYield
+
+  # Sleep if we're busy (and let other threads run).  Another less busy
+  # worker process may take it for us if we sleep. This is gross but
+  # other options still suck because they require expensive/complicated
+  # synchronization primitives for _every_ case, not just this unlikely
+  # one.  Since this case is (or should be) uncommon, just busy wait
+  # when we have to.  We don't use Thread.pass because it needlessly
+  # spins the CPU during I/O wait, CPU cycles that can be better used by
+  # other worker _processes_.
+  def worker_yield
+    sleep(0.01)
+  end
+end

data/lib/rainbows/writer_thread_pool/client.rb

@@ -0,0 +1,19 @@
+# -*- encoding: binary -*-
+# :enddoc:
+# used to wrap a BasicSocket to use with +q+ for all writes
+# this is compatible with IO.select
+class Rainbows::WriterThreadPool::Client < Struct.new(:to_io, :q)
+  include Rainbows::SocketProxy
+
+  def write(buf)
+    q << [ to_io, buf ]
+  end
+
+  def close
+    q << [ to_io, :close ]
+  end
+
+  def closed?
+    false
+  end
+end

data/lib/rainbows/writer_thread_pool.rb

@@ -1,105 +1,74 @@
 # -*- encoding: binary -*-
 
-module Rainbows
-
-  # This concurrency model implements a single-threaded app dispatch
-  # with a separate thread pool for writing responses.
-  #
-  # Unlike most \Rainbows! concurrency models, WriterThreadPool is
-  # designed to run behind nginx just like Unicorn is.  This concurrency
-  # model may be useful for existing Unicorn users looking for more
-  # output concurrency than socket buffers can provide while still
-  # maintaining a single-threaded application dispatch (though if the
-  # response body is dynamically generated, it must be thread safe).
-  #
-  # For serving large or streaming responses, using more threads (via
-  # the +worker_connections+ setting) and setting "proxy_buffering off"
-  # in nginx is recommended.  If your application does not handle
-  # uploads, then using any HTTP-aware proxy like haproxy is fine.
-  # Using a non-HTTP-aware proxy will leave you vulnerable to
-  # slow client denial-of-service attacks.
-
-  module WriterThreadPool
-    # :stopdoc:
-    include Base
-
-    # used to wrap a BasicSocket to use with +q+ for all writes
-    # this is compatible with IO.select
-    class QueueSocket < Struct.new(:to_io, :q) # :nodoc:
-      def kgio_addr
-        to_io.kgio_addr
-      end
-
-      def kgio_read(size, buf = "")
-        to_io.kgio_read(size, buf)
-      end
-
-      def kgio_read!(size, buf = "")
-        to_io.kgio_read!(size, buf)
+# This concurrency model implements a single-threaded app dispatch
+# with a separate thread pool for writing responses.
+#
+# Unlike most \Rainbows! concurrency models, WriterThreadPool is
+# designed to run behind nginx just like Unicorn is.  This concurrency
+# model may be useful for existing Unicorn users looking for more
+# output concurrency than socket buffers can provide while still
+# maintaining a single-threaded application dispatch (though if the
+# response body is dynamically generated, it must be thread safe).
+#
+# For serving large or streaming responses, using more threads (via
+# the +worker_connections+ setting) and setting "proxy_buffering off"
+# in nginx is recommended.  If your application does not handle
+# uploads, then using any HTTP-aware proxy like haproxy is fine.
+# Using a non-HTTP-aware proxy will leave you vulnerable to
+# slow client denial-of-service attacks.
+module Rainbows::WriterThreadPool
+  # :stopdoc:
+  include Rainbows::Base
+
+  @@nr = 0
+  @@q = nil
+
+  def async_write_body(qclient, body, range)
+    if body.respond_to?(:close)
+      Rainbows::SyncClose.new(body) do |body|
+        qclient.q << [ qclient.to_io, :body, body, range ]
       end
-
-      def kgio_trywrite(buf)
-        to_io.kgio_trywrite(buf)
-      end
-
-      def timed_read(buf)
-        to_io.timed_read(buf)
-      end
-
-      def write(buf)
-        q << [ to_io, buf ]
-      end
-
-      def close
-        q << [ to_io, :close ]
-      end
-
-      def closed?
-        false
-      end
-    end
-
-    @@nr = 0
-    @@q = nil
-
-    def async_write_body(qclient, body, range)
+    else
       qclient.q << [ qclient.to_io, :body, body, range ]
     end
+  end
 
-    def process_client(client) # :nodoc:
-      @@nr += 1
-      super(QueueSocket.new(client, @@q[@@nr %= @@q.size]))
-    end
+  def process_client(client) # :nodoc:
+    @@nr += 1
+    super(Client.new(client, @@q[@@nr %= @@q.size]))
+  end
 
-    def init_worker_process(worker)
-      super
-      self.class.__send__(:alias_method, :sync_write_body, :write_body)
-      WriterThreadPool.__send__(:alias_method, :write_body, :async_write_body)
-    end
+  def init_worker_process(worker)
+    super
+    self.class.__send__(:alias_method, :sync_write_body, :write_body)
+    Rainbows::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, arg3 = response
-            case arg1
-            when :body then sync_write_body(io, arg2, arg3)
-            when :close then io.close unless io.closed?
-            else
-              io.write(arg1)
-            end
-          rescue => err
-            Error.write(io, err)
+  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|
+      Rainbows::QueuePool.new(1) do |response|
+        begin
+          io, arg1, arg2, arg3 = response
+          case arg1
+          when :body then sync_write_body(io, arg2, arg3)
+          when :close then io.close unless io.closed?
+          else
+            io.write(arg1)
           end
+        rescue => err
+          Rainbows::Error.write(io, err)
         end
       end
-
-      @@q = qp.map { |q| q.queue }
-      super(worker) # accept loop from Unicorn
-      qp.map { |q| q.quit! }
     end
-    # :startdoc:
+
+    @@q = qp.map { |q| q.queue }
+    super(worker) # accept loop from Unicorn
+    qp.map { |q| q.quit! }
   end
+  # :startdoc:
 end
+# :enddoc:
+require 'rainbows/writer_thread_pool/client'

data/lib/rainbows/writer_thread_spawn/client.rb

@@ -0,0 +1,69 @@
+# -*- encoding: binary -*-
+# :enddoc:
+# used to wrap a BasicSocket to use with +q+ for all writes
+# this is compatible with IO.select
+class Rainbows::WriterThreadSpawn::Client < Struct.new(:to_io, :q, :thr)
+  include Rainbows::Response
+  include Rainbows::SocketProxy
+  include Rainbows::WorkerYield
+
+  CUR = {} # :nodoc:
+
+  def self.quit
+    g = Rainbows::G
+    CUR.delete_if do |t,q|
+      q << nil
+      g.tick
+      t.alive? ? t.join(0.01) : true
+    end until CUR.empty?
+  end
+
+  def queue_writer
+    until CUR.size < MAX
+      CUR.delete_if { |t,_|
+        t.alive? ? t.join(0) : true
+      }.size >= MAX and worker_yield
+    end
+
+    q = Queue.new
+    self.thr = Thread.new(to_io, q) do |io, q|
+      while response = q.shift
+        begin
+          arg1, arg2, arg3 = response
+          case arg1
+          when :body then write_body(io, arg2, arg3)
+          when :close
+            io.close unless io.closed?
+            break
+          else
+            io.write(arg1)
+          end
+        rescue => e
+          Rainbows::Error.write(io, e)
+        end
+      end
+      CUR.delete(Thread.current)
+    end
+    CUR[thr] = q
+  end
+
+  def write(buf)
+    (self.q ||= queue_writer) << buf
+  end
+
+  def queue_body(body, range)
+    (self.q ||= queue_writer) << [ :body, body, range ]
+  end
+
+  def close
+    if q
+      q << :close
+    else
+      to_io.close
+    end
+  end
+
+  def closed?
+    false
+  end
+end

data/lib/rainbows/writer_thread_spawn.rb

@@ -1,125 +1,45 @@
 # -*- encoding: binary -*-
 require 'thread'
-module Rainbows
-
-  # This concurrency model implements a single-threaded app dispatch and
-  # spawns a new thread for writing responses.  This concurrency model
-  # should be ideal for apps that serve large responses or stream
-  # responses slowly.
-  #
-  # Unlike most \Rainbows! concurrency models, WriterThreadSpawn is
-  # designed to run behind nginx just like Unicorn is.  This concurrency
-  # model may be useful for existing Unicorn users looking for more
-  # output concurrency than socket buffers can provide while still
-  # maintaining a single-threaded application dispatch (though if the
-  # response body is generated on-the-fly, it must be thread safe).
-  #
-  # For serving large or streaming responses, setting
-  # "proxy_buffering off" in nginx is recommended.  If your application
-  # does not handle uploads, then using any HTTP-aware proxy like
-  # haproxy is fine.  Using a non-HTTP-aware proxy will leave you
-  # vulnerable to slow client denial-of-service attacks.
-
-  module WriterThreadSpawn
-    # :stopdoc:
-    include Base
-
-    CUR = {} # :nodoc:
-
-    # used to wrap a BasicSocket to use with +q+ for all writes
-    # this is compatible with IO.select
-    class MySocket < Struct.new(:to_io, :q, :thr)  # :nodoc: all
-      include Rainbows::Response
-
-      def kgio_addr
-        to_io.kgio_addr
-      end
-
-      def kgio_read(size, buf = "")
-        to_io.kgio_read(size, buf)
-      end
-
-      def kgio_read!(size, buf = "")
-        to_io.kgio_read!(size, buf)
-      end
-
-      def kgio_trywrite(buf)
-        to_io.kgio_trywrite(buf)
-      end
-
-      def timed_read(buf)
-        to_io.timed_read(buf)
-      end
-
-      def queue_writer
-        # not using Thread.pass here because that spins the CPU during
-        # I/O wait and will eat cycles from other worker processes.
-        until CUR.size < MAX
-          CUR.delete_if { |t,_|
-            t.alive? ? t.join(0) : true
-          }.size >= MAX and sleep(0.01)
-        end
-
-        q = Queue.new
-        self.thr = Thread.new(to_io, q) do |io, q|
-          while response = q.shift
-            begin
-              arg1, arg2, arg3 = response
-              case arg1
-              when :body then write_body(io, arg2, arg3)
-              when :close
-                io.close unless io.closed?
-                break
-              else
-                io.write(arg1)
-              end
-            rescue => e
-              Error.write(io, e)
-            end
-          end
-          CUR.delete(Thread.current)
-        end
-        CUR[thr] = q
-      end
-
-      def write(buf)
-        (self.q ||= queue_writer) << buf
-      end
-
-      def queue_body(body, range)
-        (self.q ||= queue_writer) << [ :body, body, range ]
-      end
-
-      def close
-        if q
-          q << :close
-        else
-          to_io.close
-        end
-      end
-
-      def closed?
-        false
-      end
-    end
-
-    def write_body(my_sock, body, range) # :nodoc:
+# This concurrency model implements a single-threaded app dispatch and
+# spawns a new thread for writing responses.  This concurrency model
+# should be ideal for apps that serve large responses or stream
+# responses slowly.
+#
+# Unlike most \Rainbows! concurrency models, WriterThreadSpawn is
+# designed to run behind nginx just like Unicorn is.  This concurrency
+# model may be useful for existing Unicorn users looking for more
+# output concurrency than socket buffers can provide while still
+# maintaining a single-threaded application dispatch (though if the
+# response body is generated on-the-fly, it must be thread safe).
+#
+# For serving large or streaming responses, setting
+# "proxy_buffering off" in nginx is recommended.  If your application
+# does not handle uploads, then using any HTTP-aware proxy like
+# haproxy is fine.  Using a non-HTTP-aware proxy will leave you
+# vulnerable to slow client denial-of-service attacks.
+
+module Rainbows::WriterThreadSpawn
+  # :stopdoc:
+  include Rainbows::Base
+
+  def write_body(my_sock, body, range) # :nodoc:
+    if body.respond_to?(:close)
+      Rainbows::SyncClose.new(body) { |body| my_sock.queue_body(body, range) }
+    else
       my_sock.queue_body(body, range)
     end
+  end
 
-    def process_client(client) # :nodoc:
-      super(MySocket[client])
-    end
+  def process_client(client) # :nodoc:
+    super(Client.new(client))
+  end
 
-    def worker_loop(worker)  # :nodoc:
-      MySocket.const_set(:MAX, worker_connections)
-      super(worker) # accept loop from Unicorn
-      CUR.delete_if do |t,q|
-        q << nil
-        G.tick
-        t.alive? ? t.join(0.01) : true
-      end until CUR.empty?
-    end
-    # :startdoc:
+  def worker_loop(worker)  # :nodoc:
+    Client.const_set(:MAX, worker_connections)
+    super # accept loop from Unicorn
+    Client.quit
   end
+  # :startdoc:
 end
+# :enddoc:
+require 'rainbows/writer_thread_spawn/client'

data/lib/rainbows.rb

@@ -46,20 +46,22 @@ module Rainbows
   autoload :DevFdResponse, 'rainbows/dev_fd_response'
   autoload :MaxBody, 'rainbows/max_body'
   autoload :QueuePool, 'rainbows/queue_pool'
+  autoload :EvCore, 'rainbows/ev_core'
+  autoload :SocketProxy, 'rainbows/socket_proxy'
 
   class << self
 
     # Sleeps the current application dispatch.  This will pick the
     # optimal method to sleep depending on the concurrency model chosen
     # (which may still suck and block the entire process).  Using this
-    # with the basic :Rev or :EventMachine models is not recommended.
+    # with the basic :Coolio or :EventMachine models is not recommended.
     # This should be used within your Rack application.
     def sleep(nr)
       case G.server.use
       when :FiberPool, :FiberSpawn
         Rainbows::Fiber.sleep(nr)
-      when :RevFiberSpawn
-        Rainbows::Fiber::Rev::Sleeper.new(nr)
+      when :RevFiberSpawn, :CoolioFiberSpawn
+        Rainbows::Fiber::Coolio::Sleeper.new(nr)
       when :Revactor
         Actor.sleep(nr)
       else
@@ -96,12 +98,16 @@ module Rainbows
     :Rev => 50,
     :RevThreadSpawn => 50,
     :RevThreadPool => 50,
+    :RevFiberSpawn => 50,
+    :Coolio => 50,
+    :CoolioThreadSpawn => 50,
+    :CoolioThreadPool => 50,
+    :CoolioFiberSpawn => 50,
     :EventMachine => 50,
     :FiberSpawn => 50,
     :FiberPool => 50,
     :ActorSpawn => 50,
     :NeverBlock => 50,
-    :RevFiberSpawn => 50,
   }.each do |model, _|
     u = model.to_s.gsub(/([a-z0-9])([A-Z0-9])/) { "#{$1}_#{$2.downcase!}" }
     autoload model, "rainbows/#{u.downcase!}"
@@ -111,6 +117,8 @@ module Rainbows
   autoload :StreamFile, 'rainbows/stream_file'
   autoload :HttpResponse, 'rainbows/http_response' # deprecated
   autoload :ThreadTimeout, 'rainbows/thread_timeout'
+  autoload :WorkerYield, 'rainbows/worker_yield'
+  autoload :SyncClose, 'rainbows/sync_close'
 end
 
 require 'rainbows/error'

data/rainbows.gemspec

@@ -9,32 +9,24 @@ manifest = File.readlines('.manifest').map! { |x| x.chomp! }
 test_files = manifest.grep(%r{\Atest/unit/test_.*\.rb\z}).map do |f|
   File.readlines(f).grep(/\bfork\b/).empty? ? f : nil
 end.compact
+require 'wrongdoc'
+extend Wrongdoc::Gemspec
+name, summary, title = readme_metadata
 
 Gem::Specification.new do |s|
   s.name = %q{rainbows}
-  s.version = ENV["VERSION"]
+  s.version = ENV["VERSION"].dup
 
-  s.authors = ["Rainbows! hackers"]
+  s.authors = ["#{name} hackers"]
   s.date = Time.now.utc.strftime('%Y-%m-%d')
-  s.description = File.read("README").split(/\n\n/)[1]
+  s.description = readme_description
   s.email = %q{rainbows-talk@rubyforge.org}
   s.executables = %w(rainbows)
-
-  s.extra_rdoc_files = File.readlines('.document').map! do |x|
-    x.chomp!
-    if File.directory?(x)
-      manifest.grep(%r{\A#{x}/})
-    elsif File.file?(x)
-      x
-    else
-      nil
-    end
-  end.flatten.compact
-
+  s.extra_rdoc_files = extra_rdoc_files(manifest)
   s.files = manifest
-  s.homepage = %q{http://rainbows.rubyforge.org/}
-  s.summary = %q{Unicorn for sleepy apps and slow clients}
-  s.rdoc_options = [ "-t", "Rainbows! #{s.summary}" ]
+  s.homepage = Wrongdoc.config[:rdoc_url]
+  s.summary = summary
+  s.rdoc_options = rdoc_options
   s.require_paths = %w(lib)
   s.rubyforge_project = %q{rainbows}
 
@@ -44,8 +36,9 @@ Gem::Specification.new do |s|
   s.add_dependency(%q<rack>, ['~> 1.1'])
 
   # we need Unicorn for the HTTP parser and process management
-  s.add_dependency(%q<unicorn>, ["~> 3.0.0"])
+  s.add_dependency(%q<unicorn>, ["~> 3.2"])
   s.add_development_dependency(%q<isolate>, "~> 3.0.0")
+  s.add_development_dependency(%q<wrongdoc>, "~> 1.0.1")
 
   # optional runtime dependencies depending on configuration
   # see t/test_isolate.rb for the exact versions we've tested with
@@ -56,6 +49,9 @@ Gem::Specification.new do |s|
   # Revactor depends on Rev, too, 0.3.0 got the ability to attach IOs
   # s.add_dependency(%q<rev>, [">= 0.3.2"])
   #
+  # Cool.io is the new Rev, but it doesn't work with Revactor
+  # s.add_dependency(%q<cool.io>, [">= 1.0"])
+  #
   # Rev depends on IOBuffer, which got faster in 0.1.3
   # s.add_dependency(%q<iobuffer>, [">= 0.1.3"])
   #