rainbows 0.6.0 → 0.7.0

data/lib/rainbows/fiber/io.rb

@@ -0,0 +1,65 @@
+# -*- encoding: binary -*-
+module Rainbows
+  module Fiber
+
+    # A partially complete IO wrapper, this exports an IO.select()-able
+    # #to_io method and gives users the illusion of a synchronous
+    # interface that yields away from the current Fiber whenever
+    # the underlying IO object cannot read or write
+    class IO < Struct.new(:to_io, :f)
+
+      # for wrapping output response bodies
+      def each(&block)
+        begin
+          yield readpartial(16384)
+        rescue EOFError
+          break
+        end while true
+        self
+      end
+
+      def close
+        to_io.close
+      end
+
+      def write(buf)
+        begin
+          (w = to_io.write_nonblock(buf)) == buf.size and return
+          buf = buf[w..-1]
+        rescue Errno::EAGAIN
+          WR[self] = false
+          ::Fiber.yield
+          WR.delete(self)
+          retry
+        end while true
+      end
+
+      # used for reading headers (respecting keepalive_timeout)
+      def read_timeout
+        expire = nil
+        begin
+          to_io.read_nonblock(16384)
+        rescue Errno::EAGAIN
+          return if expire && expire < Time.now
+          RD[self] = false
+          expire ||= Time.now + G.kato
+          ::Fiber.yield
+          RD.delete(self)
+          retry
+        end
+      end
+
+      def readpartial(length, buf = "")
+        begin
+          to_io.read_nonblock(length, buf)
+        rescue Errno::EAGAIN
+          RD[self] = false
+          ::Fiber.yield
+          RD.delete(self)
+          retry
+        end
+      end
+
+    end
+  end
+end

data/lib/rainbows/fiber/queue.rb

@@ -0,0 +1,35 @@
+# -*- encoding: binary -*-
+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
+
+    end
+  end
+end

data/lib/rainbows/fiber_pool.rb

@@ -0,0 +1,44 @@
+# -*- encoding: binary -*-
+require 'rainbows/fiber'
+
+module Rainbows
+
+  # A Fiber-based concurrency model for Ruby 1.9.  This uses a pool of
+  # Fibers to handle client IO to run the application and the root Fiber
+  # for scheduling and connection acceptance.  The pool size is equal to
+  # the number of +worker_connections+.  Compared to the ThreadPool
+  # model, Fibers are very cheap in terms of memory usage so you can
+  # have more active connections.  This model supports a streaming
+  # "rack.input" with lightweight concurrency.  Applications are
+  # strongly advised to wrap all slow IO objects (sockets, pipes) using
+  # the Rainbows::Fiber::IO class whenever possible.
+
+  module FiberPool
+    include Fiber::Base
+
+    def worker_loop(worker)
+      init_worker_process(worker)
+      pool = []
+      worker_connections.times {
+        ::Fiber.new {
+          process_client(::Fiber.yield) while pool << ::Fiber.current
+        }.resume # resume to hit ::Fiber.yield so it waits on a client
+      }
+      Fiber::Base.const_set(:APP, app)
+
+      begin
+        schedule do |l|
+          fib = pool.shift or break # let another worker process take it
+          if io = Rainbows.accept(l)
+            fib.resume(Fiber::IO.new(io, fib))
+          else
+            pool << fib
+          end
+        end
+      rescue => e
+        Error.listen_loop(e)
+      end while G.alive || G.cur > 0
+    end
+
+  end
+end

data/lib/rainbows/fiber_spawn.rb

@@ -0,0 +1,34 @@
+# -*- encoding: binary -*-
+require 'rainbows/fiber'
+
+module Rainbows
+
+  # Simple Fiber-based concurrency model for 1.9.  This spawns a new
+  # Fiber for every incoming client connection and the root Fiber for
+  # scheduling and connection acceptance.  This exports a streaming
+  # "rack.input" with lightweight concurrency.  Applications are
+  # strongly advised to wrap all slow IO objects (sockets, pipes) using
+  # the Rainbows::Fiber::IO class whenever possible.
+
+  module FiberSpawn
+    include Fiber::Base
+
+    def worker_loop(worker)
+      init_worker_process(worker)
+      Fiber::Base.const_set(:APP, app)
+      limit = worker_connections
+      fio = Rainbows::Fiber::IO
+
+      begin
+        schedule do |l|
+          break if G.cur >= limit
+          io = Rainbows.accept(l) or next
+          ::Fiber.new { process_client(fio.new(io, ::Fiber.current)) }.resume
+        end
+      rescue => e
+        Error.listen_loop(e)
+      end while G.alive || G.cur > 0
+    end
+
+  end
+end

data/lib/rainbows/http_server.rb

@@ -52,10 +52,18 @@ module Rainbows
       Module === mod or
         raise ArgumentError, "concurrency model #{model.inspect} not supported"
       extend(mod)
+      args.each do |opt|
+        case opt
+        when Hash; O.update(opt)
+        when Symbol; O[opt] = true
+        else; raise ArgumentError, "can't handle option: #{opt.inspect}"
+        end
+      end
+      mod.setup if mod.respond_to?(:setup)
       Const::RACK_DEFAULTS['rainbows.model'] = @use = model.to_sym
       Const::RACK_DEFAULTS['rack.multithread'] = !!(/Thread/ =~ model.to_s)
       case @use
-      when :Rev, :EventMachine
+      when :Rev, :EventMachine, :NeverBlock
         Const::RACK_DEFAULTS['rainbows.autochunk'] = true
       end
     end
@@ -68,6 +76,11 @@ module Rainbows
       @worker_connections = nr
     end
 
+    def keepalive_timeout(nr)
+      (Integer === nr && nr >= 0) or
+        raise ArgumentError, "keepalive must be a non-negative Integer"
+      G.kato = nr
+    end
   end
 
 end

data/lib/rainbows/never_block.rb

@@ -0,0 +1,69 @@
+# -*- 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
+
+    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
+      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
+      G.server.extend(mod)
+      G.server.extend(Core)
+    end
+
+    module Client
+
+      def self.setup
+        const_set(:POOL, ::NB::Pool::FiberPool.new(O[:pool_size]))
+        Rainbows.const_get(O[:backend]).const_get(:Client).module_eval do
+          include Rainbows::NeverBlock::Client
+          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
+    end
+
+    module Core
+      def init_worker_process(worker)
+        super
+        Client.setup
+        logger.info "NeverBlock/#{O[:backend]} pool_size=#{O[:pool_size]}"
+      end
+    end
+
+  end
+end

data/lib/rainbows/rev.rb

@@ -24,6 +24,13 @@ module Rainbows
   # temporary file before the application is entered.
 
   module Rev
+
+    # keep-alive timeout scoreboard
+    KATO = {}
+
+    # all connected clients
+    CONN = {}
+
     include Core
   end
 end

data/lib/rainbows/rev/client.rb

@@ -8,7 +8,7 @@ module Rainbows
       G = Rainbows::G
 
       def initialize(io)
-        G.cur += 1
+        CONN[self] = false
         super(io)
         post_init
         @deferred_bodies = [] # for (fast) regular files only
@@ -23,9 +23,14 @@ module Rainbows
         schedule_write unless out_headers # triggers a write
       end
 
+      def timeout?
+        @_write_buffer.empty? && @deferred_bodies.empty? and close.nil?
+      end
+
       def app_call
         begin
-          (@env[RACK_INPUT] = @input).rewind
+          KATO.delete(self)
+          @env[RACK_INPUT] = @input
           @env[REMOTE_ADDR] = @remote_addr
           response = APP.call(@env.update(RACK_DEFAULTS))
           alive = @hp.keepalive? && G.alive
@@ -38,6 +43,7 @@ module Rainbows
             @state = :headers
             # keepalive requests are always body-less, so @input is unchanged
             @hp.headers(@env, @buf) and next
+            KATO[self] = Time.now
           else
             quit
           end
@@ -65,7 +71,7 @@ module Rainbows
       end
 
       def on_close
-        G.cur -= 1
+        CONN.delete(self)
       end
 
     end # module Client

data/lib/rainbows/rev/core.rb

@@ -11,11 +11,8 @@ module Rainbows
       # CL and MAX will be defined in the corresponding worker loop
 
       def on_readable
-        return if G.cur >= MAX
-        begin
-          CL.new(@_io.accept_nonblock).attach(LOOP)
-        rescue Errno::EAGAIN, Errno::ECONNABORTED
-        end
+        return if CONN.size >= MAX
+        io = Rainbows.accept(@_io) and CL.new(io).attach(LOOP)
       end
     end # class Server
 

data/lib/rainbows/rev/heartbeat.rb

@@ -10,7 +10,11 @@ module Rainbows
     class Heartbeat < ::Rev::TimerWatcher
 
       def on_timer
-        exit if (! G.tick && G.cur <= 0)
+        if (ot = G.kato) > 0
+          ot = Time.now - ot
+          KATO.delete_if { |client, time| time < ot and client.timeout? }
+        end
+        exit if (! G.tick && CONN.size <= 0)
       end
 
     end

data/lib/rainbows/rev_thread_spawn.rb

@@ -1,93 +1,95 @@
 # -*- encoding: binary -*-
 require 'rainbows/rev'
-require 'rainbows/ev_thread_core'
 
-warn "Rainbows::RevThreadSpawn is extremely experimental"
+RUBY_VERSION =~ %r{\A1\.8} && ::Rev::VERSION < "0.3.2" and
+  warn "Rainbows::RevThreadSpawn + Rev (< 0.3.2)" \
+       " does not work well under Ruby 1.8"
 
 module Rainbows
 
-  # This concurrency model is EXTREMELY experimental and does
-  # not perform very well.
-  #
   # A combination of the Rev and ThreadSpawn models.  This allows Ruby
-  # 1.8 and 1.9 to effectively serve more than ~1024 concurrent clients
-  # on systems that support kqueue or epoll while still using
-  # Thread-based concurrency for application processing.  It exposes
-  # Unicorn::TeeInput for a streamable "rack.input" for upload
-  # processing within the app.  Threads are spawned immediately after
-  # header processing is done for calling the application.  Rack
-  # applications running under this mode should be thread-safe.
-  # DevFdResponse should be used with this class to proxy asynchronous
-  # responses.  All network I/O between the client and server are
-  # handled by the main thread (even when streaming "rack.input").
-  #
-  # Caveats:
+  # Thread-based concurrency for application processing.  It DOES NOT
+  # expose a streamable "rack.input" for upload processing within the
+  # app.  DevFdResponse should be used with this class to proxy
+  # asynchronous responses.  All network I/O between the client and
+  # server are handled by the main thread and outside of the core
+  # application dispatch.
   #
-  # * TeeInput performance under Ruby 1.8 is terrible unless you
-  #   match the length argument of your env["rack.input"]#read
-  #   calls so that it is greater than or equal to Rev::IO::INPUT_SIZE.
-  #   Most applications depending on Rack to do multipart POST
-  #   processing should be alright as the current Rev::IO::INPUT_SIZE
-  #   of 16384 bytes matches the read size used by
-  #   Rack::Utils::Multipart::parse_multipart.
+  # WARNING: this model does not currently perform well under 1.8.  See the
+  # {rev-talk mailing list}[http://rubyforge.org/mailman/listinfo/rev-talk]
+  # for ongoing performance work that will hopefully make it into the
+  # next release of {Rev}[http://rev.rubyforge.org/].
 
   module RevThreadSpawn
-    class Client < Rainbows::Rev::Client
-      include EvThreadCore
-      LOOP = ::Rev::Loop.default
-      DR = Rainbows::Rev::DeferredResponse
-      TEE_RESUMER = ::Rev::AsyncWatcher.new
 
-      def pause
-        @lock.synchronize { disable if enabled? }
-      end
+    class Master < ::Rev::AsyncWatcher
 
-      def resume
-        @lock.synchronize { enable unless enabled? }
-        TEE_RESUMER.signal
+      def initialize
+        super
+        @queue = Queue.new
       end
 
-      def write(data)
-        if Thread.current != @thread && @lock.locked?
-          # we're being called inside on_writable
-          super
-        else
-          @lock.synchronize { super }
-        end
+      def <<(output)
+        @queue << output
+        signal
       end
 
-      def defer_body(io, out_headers)
-        @lock.synchronize { super }
+      def on_signal
+        client, response = @queue.pop
+        client.response_write(response)
       end
+    end
 
-      def response_write(response, out)
+    class Client < Rainbows::Rev::Client
+      DR = Rainbows::Rev::DeferredResponse
+      KATO = Rainbows::Rev::KATO
+
+      def response_write(response)
+        enable
+        alive = @hp.keepalive? && G.alive
+        out = [ alive ? CONN_ALIVE : CONN_CLOSE ] if @hp.headers?
         DR.write(self, response, out)
-        (out && CONN_ALIVE == out.first) or
-            @lock.synchronize {
-              quit
-              schedule_write
-            }
+        return quit unless alive && G.alive
+
+        @env.clear
+        @hp.reset
+        @state = :headers
+        # keepalive requests are always body-less, so @input is unchanged
+        if @hp.headers(@env, @buf)
+          @input = HttpRequest::NULL_IO
+          app_call
+        else
+          KATO[self] = Time.now
+        end
       end
 
-      def on_writable
-        # don't ever want to block in the main loop with lots of clients,
-        # libev is level-triggered so we'll always get another chance later
-        if @lock.try_lock
-          begin
-            super
-          ensure
-            @lock.unlock
-          end
+      # fails-safe application dispatch, we absolutely cannot
+      # afford to fail or raise an exception (killing the thread)
+      # here because that could cause a deadlock and we'd leak FDs
+      def app_response
+        begin
+          @env[REMOTE_ADDR] = @remote_addr
+          APP.call(@env.update(RACK_DEFAULTS))
+        rescue => e
+          Error.app(e) # we guarantee this does not raise
+          [ 500, {}, [] ]
         end
       end
 
+      def app_call
+        KATO.delete(client = self)
+        disable
+        @env[RACK_INPUT] = @input
+        @input = nil # not sure why, @input seems to get closed otherwise...
+        Thread.new { MASTER << [ client, app_response ] }
+      end
     end
 
     include Rainbows::Rev::Core
 
     def init_worker_process(worker)
       super
-      Client::TEE_RESUMER.attach(::Rev::Loop.default)
+      Client.const_set(:MASTER, Master.new.attach(::Rev::Loop.default))
     end
 
   end