rainbows 3.2.0 → 3.3.0

data/lib/rainbows/writer_thread_pool/client.rb

@@ -18,7 +18,7 @@ class Rainbows::WriterThreadPool::Client < Struct.new(:to_io, :q)
       }
     end
 
-    if IO.respond_to?(:copy_stream) || IO.method_defined?(:trysendfile)
+    if Rainbows::Response::COPY_STREAM || IO.method_defined?(:trysendfile)
       def write_response(status, headers, body, alive)
         if body.respond_to?(:close)
           write_response_close(status, headers, body, alive)

data/lib/rainbows/writer_thread_spawn/client.rb

@@ -21,7 +21,7 @@ class Rainbows::WriterThreadSpawn::Client < Struct.new(:to_io, :q, :thr)
       }
     end
 
-    if IO.respond_to?(:copy_stream) || IO.method_defined?(:trysendfile)
+    if Rainbows::Response::COPY_STREAM || IO.method_defined?(:trysendfile)
       def write_response(status, headers, body, alive)
         self.q ||= queue_writer
         if body.respond_to?(:close)
@@ -69,7 +69,7 @@ class Rainbows::WriterThreadSpawn::Client < Struct.new(:to_io, :q, :thr)
     end
 
     q = Queue.new
-    self.thr = Thread.new(to_io, q) do |io, q|
+    self.thr = Thread.new(to_io) do |io|
       while op = q.shift
         begin
           op, *rest = op

data/lib/rainbows/xepoll.rb

@@ -1,19 +1,26 @@
 # -*- encoding: binary -*-
-# :enddoc:
 require 'raindrops'
 require 'rainbows/epoll'
 
-# Edge-triggered epoll concurrency model with blocking accept() in
-# a (hopefully) native thread.  This is recommended over Epoll for
-# Ruby 1.9 users as it can workaround accept()-scalability issues
-# on multicore machines.
+# Edge-triggered epoll concurrency model with blocking accept() in a
+# (hopefully) native thread.  This is just like Epoll, but recommended
+# for Ruby 1.9 users as it can avoid accept()-scalability issues on
+# multicore machines with many worker processes.
+#
+# === RubyGem Requirements
+#
+# * raindrops 0.6.0 or later
+# * sleepy_penguin 2.0.0 or later
+# * sendfile 1.1.0 or later
 module Rainbows::XEpoll
+  # :stopdoc:
   include Rainbows::Base
   autoload :Client, 'rainbows/xepoll/client'
 
   def init_worker_process(worker)
     super
     Rainbows::Epoll.const_set :EP, SleepyPenguin::Epoll.new
+    Rainbows.at_quit { Rainbows::Epoll::EP.close }
     Rainbows::Client.__send__ :include, Client
   end
 
@@ -21,4 +28,5 @@ module Rainbows::XEpoll
     init_worker_process(worker)
     Client.run
   end
+  # :startdoc:
 end

data/lib/rainbows/xepoll/client.rb

@@ -5,28 +5,30 @@ module Rainbows::XEpoll::Client
   N = Raindrops.new(1)
   Rainbows::Epoll.nr_clients = lambda { N[0] }
   include Rainbows::Epoll::Client
-  MAX = Rainbows.server.worker_connections
-  THRESH = MAX - 1
   EP = Rainbows::Epoll::EP
-  THREADS = Rainbows::HttpServer::LISTENERS.map do |sock|
-    Thread.new(sock) do |sock|
-      sleep
-      begin
-        if io = sock.kgio_accept
-          N.incr(0, 1)
-          io.epoll_once
-        end
-        sleep while N[0] >= MAX
-      rescue => e
-        Rainbows::Error.listen_loop(e)
-      end while Rainbows.alive
+  ACCEPTORS = Rainbows::HttpServer::LISTENERS.dup
+  extend Rainbows::WorkerYield
+
+  def self.included(klass)
+    max = Rainbows.server.worker_connections
+    ACCEPTORS.map! do |sock|
+      Thread.new do
+        begin
+          if io = sock.kgio_accept(klass)
+            N.incr(0, 1)
+            io.epoll_once
+          end
+          worker_yield while N[0] >= max
+        rescue => e
+          Rainbows::Error.listen_loop(e)
+        end while Rainbows.alive
+      end
     end
   end
 
   def self.run
-    THREADS.each { |t| t.run }
     Rainbows::Epoll.loop
-    Rainbows::JoinThreads.acceptors(THREADS)
+    Rainbows::JoinThreads.acceptors(ACCEPTORS)
   end
 
   # only call this once
@@ -40,6 +42,6 @@ module Rainbows::XEpoll::Client
 
   def on_close
     KATO.delete(self)
-    N.decr(0, 1) == THRESH and THREADS.each { |t| t.run }
+    N.decr(0, 1)
   end
 end

data/lib/rainbows/xepoll_thread_pool.rb

@@ -0,0 +1,82 @@
+# -*- encoding: binary -*-
+require "thread"
+require "sleepy_penguin"
+require "raindrops"
+
+# This is an edge-triggered epoll concurrency model with blocking
+# accept() in a (hopefully) native thread.  This is comparable to
+# ThreadPool and CoolioThreadPool, but is Linux-only and able to exploit
+# "wake one" accept() behavior of a blocking accept() call when used
+# with native threads.
+#
+# This supports streaming "rack.input" and allows +:pool_size+ tuning
+# independently of +worker_connections+
+#
+# === Disadvantages
+#
+# This is only supported under Linux 2.6 kernels.
+#
+# === Compared to CoolioThreadPool
+#
+# This does not buffer outgoing responses in userspace at all, meaning
+# it can lower response latency to fast clients and also prevent
+# starvation of other clients when reading slow disks for responses
+# (when combined with native threads).
+#
+# CoolioThreadPool is likely better for trickling large static files or
+# proxying responses to slow clients, but this is likely better for fast
+# clients.
+#
+# Unlikely CoolioThreadPool, this supports streaming "rack.input" which
+# is useful for reading large uploads from fast clients.
+#
+# This exposes no special API or extensions on top of Rack.
+#
+# === Compared to ThreadPool
+#
+# This can maintain idle connections without the memory overhead of an
+# idle Thread.  The cost of handling/dispatching active connections is
+# exactly the same for an equivalent number of active connections
+# (but independently tunable).
+#
+# === :pool_size vs worker_connections
+#
+# Since +:pool_size+ and +worker_connections+ are independently tunable,
+# it is possible to get into situations where active connections need
+# to wait for an idle thread in the thread pool before being processed
+#
+# In your Rainbows! config block, you may specify a Thread pool size
+# to limit your application concurrency independently of
+# worker_connections.
+#
+#   Rainbows! do
+#     use :XEpollThreadPool, :pool_size => 50
+#     worker_connections 100
+#   end
+#
+# In extremely rare cases, this may be combined with Rainbows::AppPool
+# if you have different concurrency capabilities for different parts of
+# your Rack application.
+#
+# === RubyGem Requirements
+#
+# * raindrops 0.6.0 or later
+# * sleepy_penguin 2.0.0 or later
+module Rainbows::XEpollThreadPool
+  extend Rainbows::PoolSize
+
+  # :stopdoc:
+  include Rainbows::Base
+
+  def init_worker_process(worker)
+    super
+    require "rainbows/xepoll_thread_pool/client"
+    Rainbows::Client.__send__ :include, Client
+  end
+
+  def worker_loop(worker) # :nodoc:
+    init_worker_process(worker)
+    Client.loop
+  end
+  # :startdoc:
+end

data/lib/rainbows/xepoll_thread_pool/client.rb

@@ -0,0 +1,129 @@
+# -*- encoding: binary -*-
+# :enddoc:
+# FIXME: lots of duplication from xepolll_thread_spawn/client
+
+module Rainbows::XEpollThreadPool::Client
+  Rainbows.config!(self, :keepalive_timeout, :client_header_buffer_size)
+  N = Raindrops.new(1)
+  ACCEPTORS = Rainbows::HttpServer::LISTENERS.dup
+  extend Rainbows::WorkerYield
+
+  def self.included(klass) # included in Rainbows::Client
+    max = Rainbows.server.worker_connections
+    ACCEPTORS.map! do |sock|
+      Thread.new do
+        buf = ""
+        begin
+          if io = sock.kgio_accept(klass)
+            N.incr(0, 1)
+            io.epoll_once(buf)
+          end
+          worker_yield while N[0] >= max
+        rescue => e
+          Rainbows::Error.listen_loop(e)
+        end while Rainbows.alive
+      end
+    end
+  end
+
+  def self.app_run(queue)
+    while client = queue.pop
+      client.run
+    end
+  end
+
+  QUEUE = Queue.new
+  Rainbows::O[:pool_size].times { Thread.new { app_run(QUEUE) } }
+
+  ep = SleepyPenguin::Epoll
+  EP = ep.new
+  Rainbows.at_quit { EP.close }
+  IN = ep::IN | ep::ET | ep::ONESHOT
+  KATO = {}
+  KATO.compare_by_identity if KATO.respond_to?(:compare_by_identity)
+  LOCK = Mutex.new
+  @@last_expire = Time.now
+
+  def kato_set
+    LOCK.synchronize { KATO[self] = @@last_expire }
+    EP.set(self, IN)
+  end
+
+  def kato_delete
+    LOCK.synchronize { KATO.delete self }
+  end
+
+  def self.loop
+    buf = ""
+    begin
+      EP.wait(nil, 1000) { |_, obj| obj.epoll_run(buf) }
+      expire
+    rescue Errno::EINTR
+    rescue => e
+      Rainbows::Error.listen_loop(e)
+    end while Rainbows.tick || N[0] > 0
+    Rainbows::JoinThreads.acceptors(ACCEPTORS)
+  end
+
+  def self.expire
+    return if ((now = Time.now) - @@last_expire) < 1.0
+    if (ot = KEEPALIVE_TIMEOUT) >= 0
+      ot = now - ot
+      defer = []
+      LOCK.synchronize do
+        KATO.delete_if { |client, time| time < ot and defer << client }
+      end
+      defer.each { |io| io.closed? or io.close }
+    end
+    @@last_expire = now
+  end
+
+  def epoll_once(buf)
+    @hp = Rainbows::HttpParser.new
+    epoll_run(buf)
+  end
+
+  def close
+    super
+    kato_delete
+    N.decr(0, 1)
+    nil
+  end
+
+  def handle_error(e)
+    super
+    ensure
+      closed? or close
+  end
+
+  def queue!
+    QUEUE << self
+    false
+  end
+
+  def epoll_run(buf)
+    case kgio_tryread(CLIENT_HEADER_BUFFER_SIZE, buf)
+    when :wait_readable
+      return kato_set
+    when String
+      kato_delete
+      @hp.buf << buf
+      @hp.parse and return queue!
+    else
+      return close
+    end while true
+    rescue => e
+      handle_error(e)
+  end
+
+  def run
+    process_pipeline(@hp.env, @hp)
+  end
+
+  def pipeline_ready(hp)
+    # be fair to other clients, let others run first
+    hp.parse and return queue!
+    kato_set
+    false
+  end
+end

data/lib/rainbows/xepoll_thread_spawn.rb

@@ -0,0 +1,58 @@
+# -*- encoding: binary -*-
+require "thread"
+require "sleepy_penguin"
+require "raindrops"
+
+# This is an edge-triggered epoll concurrency model with blocking
+# accept() in a (hopefully) native thread.  This is comparable to
+# ThreadSpawn and CoolioThreadSpawn, but is Linux-only and able to exploit
+# "wake one" accept() behavior of a blocking accept() call when used
+# with native threads.
+#
+# This supports streaming "rack.input" and allows +:pool_size+ tuning
+# independently of +worker_connections+
+#
+# === Disadvantages
+#
+# This is only supported under Linux 2.6 kernels.
+#
+# === Compared to CoolioThreadSpawn
+#
+# This does not buffer outgoing responses in userspace at all, meaning
+# it can lower response latency to fast clients and also prevent
+# starvation of other clients when reading slow disks for responses
+# (when combined with native threads).
+#
+# CoolioThreadSpawn is likely better for trickling large static files or
+# proxying responses to slow clients, but this is likely better for fast
+# clients.
+#
+# Unlikely CoolioThreadSpawn, this supports streaming "rack.input" which
+# is useful for reading large uploads from fast clients.
+#
+# === Compared to ThreadSpawn
+#
+# This can maintain idle connections without the memory overhead of an
+# idle Thread.  The cost of handling/dispatching active connections is
+# exactly the same for an equivalent number of active connections.
+#
+# === RubyGem Requirements
+#
+# * raindrops 0.6.0 or later
+# * sleepy_penguin 2.0.0 or later
+module Rainbows::XEpollThreadSpawn
+  # :stopdoc:
+  include Rainbows::Base
+
+  def init_worker_process(worker)
+    super
+    require "rainbows/xepoll_thread_spawn/client"
+    Rainbows::Client.__send__ :include, Client
+  end
+
+  def worker_loop(worker) # :nodoc:
+    init_worker_process(worker)
+    Client.loop
+  end
+  # :startdoc:
+end

data/lib/rainbows/xepoll_thread_spawn/client.rb

@@ -0,0 +1,121 @@
+# -*- encoding: binary -*-
+# :stopdoc:
+module Rainbows::XEpollThreadSpawn::Client
+  Rainbows.config!(self, :keepalive_timeout, :client_header_buffer_size)
+  N = Raindrops.new(1)
+  ACCEPTORS = Rainbows::HttpServer::LISTENERS.dup
+  extend Rainbows::WorkerYield
+
+  def self.included(klass) # included in Rainbows::Client
+    max = Rainbows.server.worker_connections
+    ACCEPTORS.map! do |sock|
+      Thread.new do
+        buf = ""
+        begin
+          if io = sock.kgio_accept(klass)
+            N.incr(0, 1)
+            io.epoll_once(buf)
+          end
+          worker_yield while N[0] >= max
+        rescue => e
+          Rainbows::Error.listen_loop(e)
+        end while Rainbows.alive
+      end
+    end
+  end
+
+  ep = SleepyPenguin::Epoll
+  EP = ep.new
+  Rainbows.at_quit { EP.close }
+  IN = ep::IN | ep::ET | ep::ONESHOT
+  KATO = {}
+  KATO.compare_by_identity if KATO.respond_to?(:compare_by_identity)
+  LOCK = Mutex.new
+  @@last_expire = Time.now
+
+  def kato_set
+    LOCK.synchronize { KATO[self] = @@last_expire }
+    EP.set(self, IN)
+  end
+
+  def kato_delete
+    LOCK.synchronize { KATO.delete self }
+  end
+
+  def self.loop
+    buf = ""
+    begin
+      EP.wait(nil, 1000) { |_, obj| obj.epoll_run(buf) }
+      expire
+    rescue Errno::EINTR
+    rescue => e
+      Rainbows::Error.listen_loop(e)
+    end while Rainbows.tick || N[0] > 0
+    Rainbows::JoinThreads.acceptors(ACCEPTORS)
+  end
+
+  def self.expire
+    return if ((now = Time.now) - @@last_expire) < 1.0
+    if (ot = KEEPALIVE_TIMEOUT) >= 0
+      ot = now - ot
+      defer = []
+      LOCK.synchronize do
+        KATO.delete_if { |client, time| time < ot and defer << client }
+      end
+      defer.each { |io| io.closed? or io.close }
+    end
+    @@last_expire = now
+  end
+
+  def epoll_once(buf)
+    @hp = Rainbows::HttpParser.new
+    epoll_run(buf)
+  end
+
+  def close
+    super
+    kato_delete
+    N.decr(0, 1)
+    nil
+  end
+
+  def handle_error(e)
+    super
+    ensure
+      closed? or close
+  end
+
+  def epoll_run(buf)
+    case kgio_tryread(CLIENT_HEADER_BUFFER_SIZE, buf)
+    when :wait_readable
+      return kato_set
+    when String
+      kato_delete
+      @hp.buf << buf
+      env = @hp.parse and return spawn(env, @hp)
+    else
+      return close
+    end while true
+    rescue => e
+      handle_error(e)
+  end
+
+  def spawn(env, hp)
+    Thread.new { process_pipeline(env, hp) }
+  end
+
+  def pipeline_ready(hp)
+    hp.parse and return true
+    case buf = kgio_tryread(CLIENT_HEADER_BUFFER_SIZE)
+    when :wait_readable
+      kato_set
+      return false
+    when String
+      hp.buf << buf
+      hp.parse and return true
+      # continue loop
+    else
+      return close
+    end while true
+  end
+end