rainbows 2.0.1 → 2.1.0

data/lib/rainbows/fiber/io.rb

@@ -18,7 +18,7 @@ class Rainbows::Fiber::IO
   end
   # :startdoc:
 
-  # needed to write errors with
+  # no longer used internally within Rainbows!, only for compatibility
   def write_nonblock(buf)
     @to_io.write_nonblock(buf)
   end
@@ -59,19 +59,17 @@ class Rainbows::Fiber::IO
     else
       begin
         (rv = @to_io.write_nonblock(buf)) == buf.bytesize and return
-        buf = byte_slice(buf, rv..-1)
+        buf = byte_slice(buf, rv)
       rescue Errno::EAGAIN
         kgio_wait_writable
       end while true
     end
   end
 
-  def byte_slice(buf, range) # :nodoc:
-    if buf.encoding != Encoding::BINARY
-      buf.dup.force_encoding(Encoding::BINARY)[range]
-    else
-      buf[range]
-    end
+  def byte_slice(buf, start) # :nodoc:
+    buf.encoding == Encoding::BINARY or
+      buf = buf.dup.force_encoding(Encoding::BINARY)
+    buf.slice(start, buf.size)
   end
 
   # used for reading headers (respecting keepalive_timeout)
@@ -82,7 +80,7 @@ class Rainbows::Fiber::IO
         case rv = @to_io.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
@@ -93,7 +91,7 @@ class Rainbows::Fiber::IO
         return @to_io.read_nonblock(16384, buf)
       rescue Errno::EAGAIN
         return if expire && expire < Time.now
-        expire ||= Time.now + G.kato
+        expire ||= read_expire
         kgio_wait_readable
       end while true
     end

data/lib/rainbows/fiber/queue.rb

@@ -1,36 +1,30 @@
 # -*- encoding: binary -*-
 # :enddoc:
-module Rainbows
-  module Fiber
-
-    # a self-sufficient Queue implementation for Fiber-based concurrency
-    # models.  This requires no external scheduler, so it may be used with
-    # Revactor as well as FiberSpawn and FiberPool.
-    class Queue < Struct.new(:queue, :waiters)
-
-      def initialize(queue = [], waiters = [])
-        # move elements of the Queue into an Array
-        if queue.class.name == "Queue"
-          queue = queue.length.times.map { queue.pop }
-        end
-        super queue, waiters
-      end
-
-      def shift
-        # ah the joys of not having to deal with race conditions
-        if queue.empty?
-          waiters << ::Fiber.current
-          ::Fiber.yield
-        end
-        queue.shift
-      end
-
-      def <<(obj)
-        queue << obj
-        blocked = waiters.shift and blocked.resume
-        queue # not quite 100% compatible but no-one's looking :>
-      end
+#
+# a self-sufficient Queue implementation for Fiber-based concurrency
+# models.  This requires no external scheduler, so it may be used with
+# Revactor as well as FiberSpawn and FiberPool.
+class Rainbows::Fiber::Queue < Struct.new(:queue, :waiters)
+  def initialize(queue = [], waiters = [])
+    # move elements of the Queue into an Array
+    if queue.class.name == "Queue"
+      queue = queue.length.times.map { queue.pop }
+    end
+    super queue, waiters
+  end
 
+  def shift
+    # ah the joys of not having to deal with race conditions
+    if queue.empty?
+      waiters << Fiber.current
+      Fiber.yield
     end
+    queue.shift
+  end
+
+  def <<(obj)
+    queue << obj
+    blocked = waiters.shift and blocked.resume
+    queue # not quite 100% compatible but no-one's looking :>
   end
 end

data/lib/rainbows/fiber.rb

@@ -1,14 +1,16 @@
 # -*- encoding: binary -*-
-# :enddoc:
+# :stopdoc:
 begin
   require 'fiber'
 rescue LoadError
   defined?(NeverBlock) or raise
 end
+# :startdoc:
 
-# core module for all things that use Fibers in Rainbows!
+# core namespace for all things that use Fibers in \Rainbows!
 module Rainbows::Fiber
 
+  # :stopdoc:
   # blocked readers (key: fileno, value: Rainbows::Fiber::IO object)
   RD = []
 
@@ -17,6 +19,7 @@ module Rainbows::Fiber
 
   # sleeping fibers go here (key: Fiber object, value: wakeup time)
   ZZ = {}
+  # :startdoc:
 
   # puts the current Fiber into uninterruptible sleep for at least
   # +seconds+.  Unlike Kernel#sleep, this it is not possible to sleep
@@ -24,8 +27,8 @@ module Rainbows::Fiber
   # right?).  Calling this directly is deprecated, use
   # Rainbows.sleep(seconds) instead.
   def self.sleep(seconds)
-    ZZ[::Fiber.current] = Time.now + seconds
-    ::Fiber.yield
+    ZZ[Fiber.current] = Time.now + seconds
+    Fiber.yield
   end
 
   autoload :Base, 'rainbows/fiber/base'

data/lib/rainbows/fiber_pool.rb

@@ -19,7 +19,7 @@ module Rainbows::FiberPool
     worker_connections.times {
       Fiber.new {
         process(Fiber.yield) while pool << Fiber.current
-      }.resume # resume to hit ::Fiber.yield so it waits on a client
+      }.resume # resume to hit Fiber.yield so it waits on a client
     }
     Rainbows::Fiber::Base.setup(self.class, app)
 

data/lib/rainbows/http_server.rb

@@ -74,7 +74,8 @@ class Rainbows::HttpServer < Unicorn::HttpServer
     new_defaults = {
       'rainbows.model' => (@use = model.to_sym),
       'rack.multithread' => !!(model.to_s =~ /Thread/),
-      'rainbows.autochunk' => [:Rev,:EventMachine,:NeverBlock].include?(@use),
+      'rainbows.autochunk' => [:Coolio,:Rev,
+                               :EventMachine,:NeverBlock].include?(@use),
     }
     Rainbows::Const::RACK_DEFAULTS.update(new_defaults)
   end
@@ -89,10 +90,16 @@ class Rainbows::HttpServer < Unicorn::HttpServer
 
   def keepalive_timeout(nr)
     (Integer === nr && nr >= 0) or
-      raise ArgumentError, "keepalive must be a non-negative Integer"
+      raise ArgumentError, "keepalive_timeout must be a non-negative Integer"
     G.kato = nr
   end
 
+  def keepalive_requests(nr)
+    Integer === nr or
+      raise ArgumentError, "keepalive_requests must be a non-negative Integer"
+    Unicorn::HttpRequest.keepalive_requests = nr
+  end
+
   def client_max_body_size(nr)
     err = "client_max_body_size must be nil or a non-negative Integer"
     case nr

data/lib/rainbows/max_body.rb

@@ -53,7 +53,9 @@ class Rainbows::MaxBody
   def self.setup # :nodoc:
     Rainbows.max_bytes or return
     case Rainbows::G.server.use
-    when :Rev, :EventMachine, :NeverBlock, :RevThreadSpawn, :RevThreadPool
+    when :Rev, :Coolio, :EventMachine, :NeverBlock,
+         :RevThreadSpawn, :RevThreadPool,
+         :CoolioThreadSpawn, :CoolioThreadPool
       return
     end
 

data/lib/rainbows/never_block/core.rb

@@ -0,0 +1,15 @@
+# -*- encoding: binary -*-
+# :enddoc:
+module Rainbows::NeverBlock::Core
+  def init_worker_process(worker)
+    super
+    o = Rainbows::O
+    pool = NB::Pool::FiberPool.new(o[:pool_size])
+    base = o[:backend].to_s.gsub!(/([a-z])([A-Z])/, '\1_\2').downcase!
+    require "rainbows/never_block/#{base}"
+    client_class = Rainbows::NeverBlock::Client
+    client_class.superclass.const_set(:APP, Rainbows::G.server.app)
+    client_class.const_set(:POOL, pool)
+    logger.info "NeverBlock/#{o[:backend]} pool_size=#{o[:pool_size]}"
+  end
+end

data/lib/rainbows/never_block/event_machine.rb

@@ -1,8 +1,13 @@
 # -*- encoding: binary -*-
 # :enddoc:
-module Rainbows
-  module NeverBlock
-    class Client < Rainbows::EventMachine::Client
+class Rainbows::NeverBlock::Client < Rainbows::EventMachine::Client
+  def app_call
+    POOL.spawn do
+      begin
+        super
+      rescue => e
+        handle_error(e)
+      end
     end
   end
 end

data/lib/rainbows/never_block.rb

@@ -1,75 +1,42 @@
 # -*- encoding: binary -*-
 
-module Rainbows
-
-  # {NeverBlock}[www.espace.com.eg/neverblock/] library that combines
-  # the EventMachine library with Ruby Fibers.  This includes use of
-  # Thread-based Fibers under Ruby 1.8.  It currently does NOT support
-  # a streaming "rack.input" but is compatible with everything else
-  # EventMachine supports.
-  #
-  # In your Rainbows! config block, you may specify a Fiber pool size
-  # to limit your application concurrency (without using Rainbows::AppPool)
-  #
-  #   Rainbows! do
-  #     use :NeverBlock, :pool_size => 50
-  #     worker_connections 100
-  #   end
-  #
-  module NeverBlock
-
-    # :stopdoc:
-    DEFAULTS = {
-      :pool_size => 20, # same default size used by NB
-      :backend => :EventMachine, # NeverBlock doesn't support Rev yet
-    }
-
-    # same pool size NB core itself uses
-    def self.setup # :nodoc:
-      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])
-      require "never_block" # require EM first since we need a higher version
-    end
-
-    def self.extended(klass)
-      klass.extend(Rainbows.const_get(O[:backend])) # EventMachine
-      klass.extend(Core)
-    end
-
-    module Core  # :nodoc: all
-      def self.setup
-        self.const_set(:POOL, ::NB::Pool::FiberPool.new(O[:pool_size]))
-        base = O[:backend].to_s.gsub!(/([a-z])([A-Z])/, '\1_\2').downcase!
-        require "rainbows/never_block/#{base}"
-        Rainbows::NeverBlock.const_get(:Client).class_eval do
-          self.superclass.const_set(:APP, G.server.app)
-          include Rainbows::NeverBlock::Core
-          alias _app_call app_call
-          undef_method :app_call
-          alias app_call nb_app_call
-        end
-      end
-
-      def nb_app_call
-        POOL.spawn do
-          begin
-            _app_call
-          rescue => e
-            handle_error(e)
-          end
-        end
-      end
-
-      def init_worker_process(worker)
-        super
-        Core.setup
-        logger.info "NeverBlock/#{O[:backend]} pool_size=#{O[:pool_size]}"
-      end
-    end
-
-    # :startdoc:
+# {NeverBlock}[www.espace.com.eg/neverblock/] library that combines
+# the EventMachine library with Ruby Fibers.  This includes use of
+# Thread-based Fibers under Ruby 1.8.  It currently does NOT support
+# a streaming "rack.input" but is compatible with everything else
+# EventMachine supports.
+#
+# In your Rainbows! config block, you may specify a Fiber pool size
+# to limit your application concurrency (without using Rainbows::AppPool)
+#
+#   Rainbows! do
+#     use :NeverBlock, :pool_size => 50
+#     worker_connections 100
+#   end
+#
+module Rainbows::NeverBlock
+
+  # :stopdoc:
+  DEFAULTS = {
+    :pool_size => 20, # same default size used by NB
+    :backend => :EventMachine, # NeverBlock doesn't support Rev yet
+  }
+
+  # 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])
+    require "never_block" # require EM first since we need a higher version
+  end
 
+  def self.extended(klass)
+    klass.extend(Rainbows.const_get(Rainbows::O[:backend])) # EventMachine
+    klass.extend(Rainbows::NeverBlock::Core)
   end
+  # :startdoc:
 end
+# :enddoc:
+require 'rainbows/never_block/core'

data/lib/rainbows/process_client.rb

@@ -1,12 +1,11 @@
 # -*- encoding: binary -*-
 # :enddoc:
+require 'rainbows/rack_input'
 module Rainbows::ProcessClient
   G = Rainbows::G
   include Rainbows::Response
   HttpParser = Unicorn::HttpParser
-  NULL_IO = Unicorn::HttpRequest::NULL_IO
-  RACK_INPUT = Unicorn::HttpRequest::RACK_INPUT
-  TeeInput = Unicorn::TeeInput
+  include Rainbows::RackInput
   include Rainbows::Const
 
   # once a client is accepted, it is processed in its entirety here
@@ -25,9 +24,7 @@ module Rainbows::ProcessClient
         buf << buf2
       end
 
-      env[CLIENT_IO] = client
-      env[RACK_INPUT] = 0 == hp.content_length ?
-                        NULL_IO : TeeInput.new(client, hp)
+      set_input(env, hp, client)
       env[REMOTE_ADDR] = remote_addr
       status, headers, body = APP.call(env.update(RACK_DEFAULTS))
 

data/lib/rainbows/rack_input.rb

@@ -0,0 +1,17 @@
+# -*- encoding: binary -*-
+# :enddoc:
+# only used by synchronous interfaces
+module Rainbows::RackInput
+  NULL_IO = Unicorn::HttpRequest::NULL_IO
+  RACK_INPUT = Unicorn::HttpRequest::RACK_INPUT
+  CLIENT_IO = Rainbows::Const::CLIENT_IO
+
+  def self.setup
+    const_set(:IC, Unicorn::HttpRequest.input_class)
+  end
+
+  def set_input(env, hp, client)
+    env[RACK_INPUT] = 0 == hp.content_length ? NULL_IO : IC.new(client, hp)
+    env[CLIENT_IO] = client
+  end
+end

data/lib/rainbows/response/body.rb

@@ -32,8 +32,14 @@ module Rainbows::Response::Body # :nodoc:
 
   FD_MAP = Rainbows::FD_MAP
 
+  class F < File; end
+
+  def close_if_private(io)
+    io.close if F === io
+  end
+
   def io_for_fd(fd)
-    FD_MAP.delete(fd) || IO.new(fd)
+    FD_MAP.delete(fd) || F.for_fd(fd)
   end
 
   # to_io is not part of the Rack spec, but make an exception here
@@ -47,13 +53,16 @@ module Rainbows::Response::Body # :nodoc:
       # try to take advantage of Rainbows::DevFdResponse, calling File.open
       # is a last resort
       path = body.to_path
-      path =~ %r{\A/dev/fd/(\d+)\z} ? io_for_fd($1.to_i) : File.open(path)
+      path =~ %r{\A/dev/fd/(\d+)\z} ? io_for_fd($1.to_i) : F.open(path)
     end
   end
 
   if IO.method_defined?(:sendfile_nonblock)
     def write_body_file(sock, body, range)
-      range ? sock.sendfile(body, range[0], range[1]) : sock.sendfile(body, 0)
+      io = body_to_io(body)
+      range ? sock.sendfile(io, range[0], range[1]) : sock.sendfile(io, 0)
+      ensure
+        close_if_private(io)
     end
   end
 
@@ -70,8 +79,6 @@ module Rainbows::Response::Body # :nodoc:
     # pread() semantics
     def write_body_stream(sock, body, range)
       IO.copy_stream(body, sock)
-      ensure
-        body.respond_to?(:close) and body.close
     end
   else
     # fall back to body#each, which is a Rack standard
@@ -79,27 +86,19 @@ module Rainbows::Response::Body # :nodoc:
   end
 
   if method_defined?(:write_body_file)
-
     # middlewares/apps may return with a body that responds to +to_path+
     def write_body_path(sock, body, range)
-      inp = body_to_io(body)
-      if inp.stat.file?
-        begin
-          write_body_file(sock, inp, range)
-        ensure
-          inp.close if inp != body
-        end
-      else
-        write_body_stream(sock, inp, range)
-      end
+      stat = File.stat(body.to_path)
+      stat.file? ? write_body_file(sock, body, range) :
+                   write_body_stream(sock, body, range)
       ensure
-        body.respond_to?(:close) && inp != body and body.close
+        body.respond_to?(:close) and body.close
     end
   elsif method_defined?(:write_body_stream)
     def write_body_path(sock, body, range)
-      write_body_stream(sock, inp = body_to_io(body), range)
+      write_body_stream(sock, body, range)
       ensure
-        body.respond_to?(:close) && inp != body and body.close
+        body.respond_to?(:close) and body.close
     end
   end
 

data/lib/rainbows/response.rb

@@ -38,7 +38,7 @@ module Rainbows::Response
     range_class = body_class = klass
     case Rainbows::Const::RACK_DEFAULTS['rainbows.model']
     when :WriterThreadSpawn
-      body_class = Rainbows::WriterThreadSpawn::MySocket
+      body_class = Rainbows::WriterThreadSpawn::Client
       range_class = Rainbows::HttpServer
     when :EventMachine, :NeverBlock
       range_class = nil # :<

data/lib/rainbows/rev.rb

@@ -1,44 +1,22 @@
 # -*- encoding: binary -*-
-require 'rainbows/rev/core'
-require 'rainbows/rev/client'
-
-module Rainbows
-
-  # Implements a basic single-threaded event model with
-  # {Rev}[http://rev.rubyforge.org/].  It is capable of handling
-  # thousands of simultaneous client connections, but with only a
-  # single-threaded app dispatch.  It is suited for slow clients and
-  # fast applications (applications that do not have slow network
-  # dependencies) or applications that use DevFdResponse for deferrable
-  # response bodies.  It does not require your Rack application to be
-  # thread-safe, reentrancy is only required for the DevFdResponse body
-  # generator.
-  #
-  # Compatibility: Whatever \Rev itself supports, currently Ruby
-  # 1.8/1.9.
-  #
-  # This model does not implement as streaming "rack.input" which
-  # allows the Rack application to process data as it arrives.  This
-  # means "rack.input" will be fully buffered in memory or to a
-  # temporary file before the application is entered.
-
-  module Rev
-
-    # :stopdoc:
-    # keep-alive timeout scoreboard
-    KATO = {}
-
-    # all connected clients
-    CONN = {}
-
-    if {}.respond_to?(:compare_by_identity)
-      CONN.compare_by_identity
-      KATO.compare_by_identity
-    end
-
-    autoload :DeferredResponse,'rainbows/rev/deferred_response'
-    autoload :DeferredChunkResponse,'rainbows/rev/deferred_chunk_response'
-    include Core
-    # :startdoc:
-  end
-end
+Rainbows.const_set(:Rev, Rainbows::Coolio)
+# Coolio is the new version of this, use that instead.
+#
+# Implements a basic single-threaded event model with
+# {Rev}[http://rev.rubyforge.org/].  It is capable of handling
+# thousands of simultaneous client connections, but with only a
+# single-threaded app dispatch.  It is suited for slow clients and
+# fast applications (applications that do not have slow network
+# dependencies) or applications that use DevFdResponse for deferrable
+# response bodies.  It does not require your Rack application to be
+# thread-safe, reentrancy is only required for the DevFdResponse body
+# generator.
+#
+# Compatibility: Whatever \Rev itself supports, currently Ruby
+# 1.8/1.9.
+#
+# This model does not implement as streaming "rack.input" which
+# allows the Rack application to process data as it arrives.  This
+# means "rack.input" will be fully buffered in memory or to a
+# temporary file before the application is entered.
+module Rainbows::Rev; end

data/lib/rainbows/rev_fiber_spawn.rb

@@ -1,6 +1,8 @@
 # -*- encoding: binary -*-
-require 'rainbows/fiber/rev'
+Rainbows.const_set(:RevFiberSpawn, Rainbows::CoolioFiberSpawn)
 
+# CoolioFiberSpawn is the new version of this, use that instead.
+#
 # A combination of the Rev and FiberSpawn models.  This allows Ruby
 # 1.9 Fiber-based concurrency for application processing while
 # exposing a synchronous execution model and using scalable network
@@ -8,21 +10,4 @@ require 'rainbows/fiber/rev'
 # being Sunshowers-compatible.  Applications are strongly advised to
 # wrap all slow IO objects (sockets, pipes) using the
 # Rainbows::Fiber::IO or a Rev-compatible class whenever possible.
-module Rainbows::RevFiberSpawn
-
-  include Rainbows::Base
-  include Rainbows::Fiber::Rev
-
-  def worker_loop(worker) # :nodoc:
-    Rainbows::Response.setup(Server)
-    init_worker_process(worker)
-    Server.const_set(:MAX, @worker_connections)
-    Rainbows::Fiber::Base.setup(Server, nil)
-    Server.const_set(:APP, G.server.app)
-    Heartbeat.new(1, true).attach(Rev::Loop.default)
-    kato = Kato.new.attach(Rev::Loop.default)
-    Rainbows::Fiber::Rev::Methods.const_set(:KATO, kato)
-    LISTENERS.map! { |s| Server.new(s).attach(Rev::Loop.default) }
-    Rev::Loop.default.run
-  end
-end
+module Rainbows::RevFiberSpawn; end