rainbows 0.9.0 → 0.90.0

data/Documentation/comparison.haml

@@ -92,6 +92,13 @@
     %td.r19 Yes
     %td.rbx No
     %td.slow Yes
+  %tr.comp_row
+    %td.mod RevFiberSpawn
+    %td.tee Yes
+    %td.r18 No
+    %td.r19 Yes
+    %td.rbx No
+    %td.slow Yes
 %ul
   %li
     RevThread* + 1.8 performance is bad with Rev <= 0.3.1.
@@ -191,6 +198,12 @@
       %a(href="http://rev.rubyforge.org/") Rev
     %td.thr Yes
     %td.reent No
+  %tr.comp_row
+    %td.mod RevFiberSpawn
+    %td.slowio
+      %a(href="Rainbows/Fiber/IO.html") Rainbows::Fiber::IO
+    %td.thr No
+    %td.reent Yes
 
 %ul
   %li
@@ -276,14 +289,14 @@
     %td.devfd Yes
     %td.app_pool Yes
     %td.lock No!
-    %td.async Rainbows::Fiber{::IO,.sleep}
+    %td.async Rainbows::Fiber::IO, Rainbows.sleep
     %td.ws Sunshowers
   %tr.comp_row
     %td.mod FiberPool
     %td.devfd Yes
     %td.app_pool Yes
     %td.lock No!
-    %td.async Rainbows::Fiber{::IO,.sleep}
+    %td.async Rainbows::Fiber::IO, Rainbows.sleep
     %td.ws Sunshowers
   %tr.comp_row
     %td.mod ActorSpawn
@@ -306,6 +319,12 @@
     %td.lock Dumb
     %td.async standard Ruby
     %td.ws no
+  %tr.comp_row
+    %td.mod RevFiberSpawn
+    %td.devfd Yes
+    %td.app_pool Yes
+    %td.lock No!
+    %td.async Rainbows::Fiber::IO, Rainbows.sleep
 
 %ul
   %li

data/GIT-VERSION-GEN

@@ -1,7 +1,7 @@
 #!/bin/sh
 
 GVF=GIT-VERSION-FILE
-DEF_VER=v0.9.0.GIT
+DEF_VER=v0.90.0.GIT
 
 LF='
 '

data/GNUmakefile

@@ -58,7 +58,7 @@ NEWS: GIT-VERSION-FILE
 	$(RAKE) -s news_rdoc > $@+
 	mv $@+ $@
 
-SINCE = 0.8.0
+SINCE = 0.9.0
 ChangeLog: LOG_VERSION = \
   $(shell git rev-parse -q "$(GIT_VERSION)" >/dev/null 2>&1 && \
           echo $(GIT_VERSION) || git describe)
@@ -155,7 +155,7 @@ package: $(pkgtgz) $(pkggem)
 release: verify package $(release_notes) $(release_changes)
 	# make tgz release on RubyForge
 	rubyforge add_release -f -n $(release_notes) -a $(release_changes) \
-	  $(rfproject) $(rfpackage) $(VERSION) $(pkggem)
+	  $(rfproject) $(rfpackage) $(VERSION) $(pkgtgz)
 	# push gem to Gemcutter
 	gem push $(pkggem)
 	# in case of gem downloads from RubyForge releases page

data/README

@@ -13,6 +13,7 @@ suck; differently.
 
 For network concurrency, models we currently support are:
 
+* {RevFiberSpawn}[link:Rainbows/RevFiberSpawn.html]
 * {Revactor}[link:Rainbows/Revactor.html]
 * {ThreadPool}[link:Rainbows/ThreadPool.html]
 * {Rev}[link:Rainbows/Rev.html]
@@ -155,7 +156,7 @@ and we'll try our best to fix it.
 
 == Contact
 
-All feedback (bug reports, user/development dicussion, patches, pull
+All feedback (bug reports, user/development discussion, patches, pull
 requests) go to the mailing list/newsgroup.  Patches must be sent inline
 (git format-patch -M + git send-email).  No subscription is necessary
 to post on the mailing list.  No top posting.  Address replies +To:+

data/Rakefile

@@ -164,8 +164,8 @@ task :fm_update do
   require 'net/netrc'
   require 'json'
   version = ENV['VERSION'] or abort "VERSION= needed"
-  uri = URI.parse('http://freshmeat.net/projects/unicorn/releases.json')
-  rc = Net::Netrc.locate('unicorn-fm') or abort "~/.netrc not found"
+  uri = URI.parse('http://freshmeat.net/projects/rainbows/releases.json')
+  rc = Net::Netrc.locate('rainbows-fm') or abort "~/.netrc not found"
   api_token = rc.password
   changelog = tags.find { |t| t[:tag] == "v#{version}" }[:body]
   tmp = Tempfile.new('fm-changelog')

data/TODO

@@ -14,7 +14,11 @@ care about.
 * conditional app.deferred?(env) support
   Merb uses it, some other servers support it
 
-* {Rev,EventMachine}+Fibers+streaming input
+* EventMachine+Fibers+streaming input
+
+* RevFiberPool
+
+* ThreadPoolRevFiber{Spawn,Pool}: just because
 
 * Rev + callcc - current Rev model with callcc (should work with MBARI)
 

data/bin/rainbows

@@ -1,4 +1,4 @@
-#!/home/ew/bin/ruby
+#!/this/will/be/overwritten/or/wrapped/anyways/do/not/worry/ruby
 # -*- encoding: binary -*-
 require 'unicorn/launcher'
 require 'rainbows'

data/lib/rainbows.rb

@@ -34,11 +34,44 @@ module Rainbows
 
   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.
+    # 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 :Revactor
+        Actor.sleep(nr)
+      else
+        Kernel.sleep(nr)
+      end
+    end
+
     # runs the Rainbows! HttpServer with +app+ and +options+ and does
     # not return until the server has exited.
     def run(app, options = {})
       HttpServer.new(app, options).start.join
     end
+
+    # returns nil if accept fails
+    if defined?(Fcntl::FD_CLOEXEC)
+      def accept(sock)
+        rv = sock.accept_nonblock
+        rv.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+        rv
+      rescue Errno::EAGAIN, Errno::ECONNABORTED
+      end
+    else
+      def accept(sock)
+        sock.accept_nonblock
+      rescue Errno::EAGAIN, Errno::ECONNABORTED
+      end
+    end
   end
 
   # configures \Rainbows! with a given concurrency model to +use+ and
@@ -87,27 +120,13 @@ module Rainbows
     :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!}"
   end
   autoload :Fiber, 'rainbows/fiber' # core class
 
-  # returns nil if accept fails
-  if defined?(Fcntl::FD_CLOEXEC)
-    def self.accept(sock)
-      rv = sock.accept_nonblock
-      rv.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
-      rv
-    rescue Errno::EAGAIN, Errno::ECONNABORTED
-    end
-  else
-    def self.accept(sock)
-      sock.accept_nonblock
-    rescue Errno::EAGAIN, Errno::ECONNABORTED
-    end
-  end
-
 end
 
 # inject the Rainbows! method into Unicorn::Configurator

data/lib/rainbows/app_pool.rb

@@ -91,7 +91,7 @@ module Rainbows
       # concurrency models
       self.re ||= begin
         case env["rainbows.model"]
-        when :FiberSpawn, :FiberPool, :Revactor, :NeverBlock
+        when :FiberSpawn, :FiberPool, :Revactor, :NeverBlock, :RevFiberSpawn
           self.pool = Rainbows::Fiber::Queue.new(pool)
         end
         true

data/lib/rainbows/base.rb

@@ -10,15 +10,16 @@ module Rainbows
     include Rainbows::Const
     G = Rainbows::G
 
-    def handle_error(client, e)
-      msg = Error.response(e) and client.write_nonblock(msg)
-      rescue
-    end
-
     def init_worker_process(worker)
       super(worker)
       G.tmp = worker.tmp
 
+      # avoid spurious wakeups and blocking-accept() with 1.8 green threads
+      if RUBY_VERSION.to_f < 1.9
+        require "io/nonblock"
+        HttpServer::LISTENERS.each { |l| l.nonblock = true }
+      end
+
       # we're don't use the self-pipe mechanism in the Rainbows! worker
       # since we don't defer reopening logs
       HttpServer::SELF_PIPE.each { |x| x.close }.clear
@@ -65,17 +66,9 @@ module Rainbows
     # if the socket is already closed or broken.  We'll always ensure
     # the socket is closed at the end of this function
     rescue => e
-      handle_error(client, e)
+      Error.write(client, e)
     ensure
-      client.close
-    end
-
-    def join_threads(threads)
-      G.quit!
-      threads.delete_if do |thr|
-        G.tick
-        thr.alive? ? thr.join(0.01) : true
-      end until threads.empty?
+      client.close unless client.closed?
     end
 
     def self.included(klass)

data/lib/rainbows/const.rb

@@ -3,21 +3,21 @@
 module Rainbows
 
   module Const
-    RAINBOWS_VERSION = '0.9.0'
+    RAINBOWS_VERSION = '0.90.0'
 
     include Unicorn::Const
 
-    RACK_DEFAULTS = ::Unicorn::HttpRequest::DEFAULTS.merge({
+    RACK_DEFAULTS = Unicorn::HttpRequest::DEFAULTS.update({
       "SERVER_SOFTWARE" => "Rainbows! #{RAINBOWS_VERSION}",
 
       # using the Rev model, we'll automatically chunk pipe and socket objects
-      # if they're the response body
-      'rainbows.autochunk' => false,
+      # if they're the response body.  Unset by default.
+      # "rainbows.autochunk" => false,
     })
 
     CONN_CLOSE = "Connection: close\r\n"
     CONN_ALIVE = "Connection: keep-alive\r\n"
-    LOCALHOST = "127.0.0.1"
+    LOCALHOST = Unicorn::HttpRequest::LOCALHOST
 
     # client IO object that supports reading and writing directly
     # without filtering it through the HTTP chunk parser.

data/lib/rainbows/dev_fd_response.rb

@@ -39,7 +39,7 @@ module Rainbows
 
         # we need to make sure our pipe output is Fiber-compatible
         case env["rainbows.model"]
-        when :FiberSpawn, :FiberPool
+        when :FiberSpawn, :FiberPool, :RevFiberSpawn
           return [ status, headers.to_hash, Fiber::IO.new(io,::Fiber.current) ]
         end
       else # unlikely, char/block device file, directory, ...

data/lib/rainbows/error.rb

@@ -4,6 +4,15 @@ module Rainbows
   class Error
     class << self
 
+      # if we get any error, try to write something back to the client
+      # assuming we haven't closed the socket, but don't get hung up
+      # if the socket is already closed or broken.  We'll always ensure
+      # the socket is closed at the end of this function
+      def write(io, e)
+        msg = Error.response(e) and io.write_nonblock(msg)
+        rescue
+      end
+
       def app(e)
         G.server.logger.error "app error: #{e.inspect}"
         G.server.logger.error e.backtrace.join("\n")
@@ -19,7 +28,7 @@ module Rainbows
 
       def response(e)
         case e
-        when EOFError, Errno::ECONNRESET,Errno::EPIPE,Errno::EINVAL,Errno::EBADF
+        when EOFError,Errno::ECONNRESET,Errno::EPIPE,Errno::EINVAL,Errno::EBADF
           # swallow error if client shuts down one end or disconnects
         when Unicorn::HttpParserError
           Const::ERROR_400_RESPONSE # try to tell the client they're bad

data/lib/rainbows/ev_core.rb

@@ -11,10 +11,6 @@ module Rainbows
     # Apps may return this Rack response: AsyncResponse = [ -1, {}, [] ]
     ASYNC_CALLBACK = "async.callback".freeze
 
-    def self.setup(klass)
-      klass.const_set(:APP, G.server.app)
-    end
-
     def post_init
       @remote_addr = ::TCPSocket === @_io ? @_io.peeraddr.last : LOCALHOST
       @env = {}

data/lib/rainbows/event_machine.rb

@@ -190,7 +190,7 @@ module Rainbows
       client_class = Rainbows.const_get(@use).const_get(:Client)
       Server.const_set(:MAX, worker_connections + LISTENERS.size)
       Server.const_set(:CL, client_class)
-      EvCore.setup(client_class)
+      client_class.const_set(:APP, G.server.app)
       EM.run {
         conns = EM.instance_variable_get(:@conns) or
           raise RuntimeError, "EM @conns instance variable not accessible!"

data/lib/rainbows/fiber/base.rb

@@ -16,7 +16,8 @@ module Rainbows
     # puts the current Fiber into uninterruptible sleep for at least
     # +seconds+.  Unlike Kernel#sleep, this it is not possible to sleep
     # indefinitely to be woken up (nobody wants that in a web server,
-    # right?).
+    # right?).  Calling this directly is deprecated, use
+    # Rainbows.sleep(seconds) instead.
     def self.sleep(seconds)
       ZZ[::Fiber.current] = Time.now + seconds
       ::Fiber.yield
@@ -99,7 +100,7 @@ module Rainbows
           HttpResponse.write(client, response, out)
         end while alive and hp.reset.nil? and env.clear
       rescue => e
-        handle_error(io, e)
+        Error.write(io, e)
       ensure
         G.cur -= 1
         RD.delete(client)

data/lib/rainbows/fiber/io.rb

@@ -22,14 +22,24 @@ module Rainbows
         to_io.close
       end
 
+      def wait_readable
+        RD[self] = false
+        ::Fiber.yield
+        RD.delete(self)
+      end
+
+      def wait_writable
+        WR[self] = false
+        ::Fiber.yield
+        WR.delete(self)
+      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)
+          wait_writable
           retry
         end while true
       end
@@ -41,10 +51,8 @@ module Rainbows
           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)
+          wait_readable
           retry
         end
       end
@@ -53,9 +61,7 @@ module Rainbows
         begin
           to_io.read_nonblock(length, buf)
         rescue Errno::EAGAIN
-          RD[self] = false
-          ::Fiber.yield
-          RD.delete(self)
+          wait_readable
           retry
         end
       end

data/lib/rainbows/fiber/rev.rb

@@ -0,0 +1,160 @@
+# -*- encoding: binary -*-
+require 'rev'
+require 'rainbows/fiber'
+require 'rainbows/fiber/io'
+
+module Rainbows::Fiber
+  module Rev
+    G = Rainbows::G
+
+    # keep-alive timeout class
+    class Kato < ::Rev::TimerWatcher
+      def initialize
+        @watch = []
+        super(1, true)
+      end
+
+      def <<(fiber)
+        @watch << fiber
+        enable unless enabled?
+      end
+
+      def on_timer
+        @watch.uniq!
+        while f = @watch.shift
+          f.resume if f.alive?
+        end
+        disable
+      end
+    end
+
+    class Heartbeat < ::Rev::TimerWatcher
+      def on_timer
+        exit if (! G.tick && G.cur <= 0)
+      end
+    end
+
+    class Sleeper < ::Rev::TimerWatcher
+
+      def initialize(seconds)
+        @f = ::Fiber.current
+        super(seconds, false)
+        attach(::Rev::Loop.default)
+        ::Fiber.yield
+      end
+
+      def on_timer
+        @f.resume
+      end
+    end
+
+    class Server < ::Rev::IOWatcher
+      include Unicorn
+      include Rainbows
+      include Rainbows::Const
+      FIO = Rainbows::Fiber::IO
+
+      def to_io
+        @io
+      end
+
+      def initialize(io)
+        @io = io
+        super(self, :r)
+      end
+
+      def close
+        detach if attached?
+        @io.close
+      end
+
+      def on_readable
+        return if G.cur >= MAX
+        c = Rainbows.accept(@io) and ::Fiber.new { process(c) }.resume
+      end
+
+      def process(io)
+        G.cur += 1
+        client = FIO.new(io, ::Fiber.current)
+        buf = client.read_timeout or return
+        hp = HttpParser.new
+        env = {}
+        alive = true
+        remote_addr = TCPSocket === io ? io.peeraddr.last : LOCALHOST
+
+        begin # loop
+          buf << (client.read_timeout or return) until hp.headers(env, buf)
+
+          env[CLIENT_IO] = client
+          env[RACK_INPUT] = 0 == hp.content_length ?
+                    HttpRequest::NULL_IO : TeeInput.new(client, env, hp, buf)
+          env[REMOTE_ADDR] = remote_addr
+          response = APP.call(env.update(RACK_DEFAULTS))
+
+          if 100 == response.first.to_i
+            client.write(EXPECT_100_RESPONSE)
+            env.delete(HTTP_EXPECT)
+            response = APP.call(env)
+          end
+
+          alive = hp.keepalive? && G.alive
+          out = [ alive ? CONN_ALIVE : CONN_CLOSE ] if hp.headers?
+          HttpResponse.write(client, response, out)
+        end while alive and hp.reset.nil? and env.clear
+      rescue => e
+        Error.write(io, e)
+      ensure
+        G.cur -= 1
+        client.close
+      end
+    end
+  end
+
+  class IO # see rainbows/fiber/io for original definition
+
+    class Watcher < ::Rev::IOWatcher
+      def initialize(fio, flag)
+        @fiber = fio.f
+        super(fio, flag)
+        attach(::Rev::Loop.default)
+      end
+
+      def on_readable
+        @fiber.resume
+      end
+
+      alias on_writable on_readable
+    end
+
+    undef_method :wait_readable
+    undef_method :wait_writable
+    undef_method :close
+
+    def initialize(*args)
+      super
+      @r = @w = false
+    end
+
+    def close
+      @w.detach if @w
+      @r.detach if @r
+      @r = @w = false
+      to_io.close unless to_io.closed?
+    end
+
+    def wait_writable
+      @w ||= Watcher.new(self, :w)
+      @w.enable unless @w.enabled?
+      ::Fiber.yield
+      @w.disable
+    end
+
+    def wait_readable
+      @r ||= Watcher.new(self, :r)
+      @r.enable unless @r.enabled?
+      KATO << f
+      ::Fiber.yield
+      @r.disable
+    end
+  end
+end

data/lib/rainbows/rev/core.rb

@@ -27,7 +27,7 @@ module Rainbows
         rloop = Server.const_set(:LOOP, ::Rev::Loop.default)
         Server.const_set(:MAX, @worker_connections)
         Server.const_set(:CL, mod.const_get(:Client))
-        EvCore.setup(EvCore)
+        EvCore.const_set(:APP, G.server.app)
         Heartbeat.new(1, true).attach(rloop)
         LISTENERS.map! { |s| Server.new(s).attach(rloop) }
         rloop.run

data/lib/rainbows/rev_fiber_spawn.rb

@@ -0,0 +1,29 @@
+# -*- encoding: binary -*-
+require 'rainbows/fiber/rev'
+
+module Rainbows
+
+  # 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
+  # concurrency provided by Rev.  A "rack.input" is exposed as well
+  # 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 RevFiberSpawn
+
+    include Base
+    include Fiber::Rev
+
+    def worker_loop(worker)
+      init_worker_process(worker)
+      Server.const_set(:MAX, @worker_connections)
+      Server.const_set(:APP, G.server.app)
+      Heartbeat.new(1, true).attach(::Rev::Loop.default)
+      kato = Kato.new.attach(::Rev::Loop.default)
+      Rainbows::Fiber::IO.const_set(:KATO, kato)
+      LISTENERS.map! { |s| Server.new(s).attach(::Rev::Loop.default) }
+      ::Rev::Loop.default.run
+    end
+  end
+end

data/lib/rainbows/revactor.rb

@@ -68,7 +68,7 @@ module Rainbows
       end while alive and hp.reset.nil? and env.clear
     rescue ::Revactor::TCP::ReadError
     rescue => e
-      handle_error(client, e)
+      Error.write(client.instance_eval { @_io }, e)
     ensure
       client.close
     end
@@ -121,17 +121,6 @@ module Rainbows
       rescue Errno::EMFILE => e
     end
 
-    # if we get any error, try to write something back to the client
-    # assuming we haven't closed the socket, but don't get hung up
-    # if the socket is already closed or broken.  We'll always ensure
-    # the socket is closed at the end of this function
-    def handle_error(client, e)
-      # this is Revactor implementation dependent
-      msg = Error.response(e) and
-        client.instance_eval { @_io.write_nonblock(msg) }
-      rescue
-    end
-
     def revactorize_listeners
       LISTENERS.map do |s|
         case s

data/lib/rainbows/thread_pool.rb

@@ -67,5 +67,13 @@ module Rainbows
       end while G.alive
     end
 
+    def join_threads(threads)
+      G.quit!
+      threads.delete_if do |thr|
+        G.tick
+        thr.alive? ? thr.join(0.01) : true
+      end until threads.empty?
+    end
+
   end
 end

data/t/GNUmakefile

@@ -28,6 +28,7 @@ ONENINE := $(shell case $(RUBY_VERSION) in 1.9.*$(rp) echo true;;esac)
 ifeq ($(ONENINE),true)
   models += Revactor
   models += FiberSpawn
+  models += RevFiberSpawn
   models += FiberPool
 
   # technically this works under 1.8, but wait until rev 0.3.2

data/t/simple-http_RevFiberSpawn.ru

@@ -0,0 +1,10 @@
+use Rack::ContentLength
+use Rack::ContentType
+run lambda { |env|
+  if env['rack.multithread'] == false &&
+    env['rainbows.model'] == :RevFiberSpawn
+    [ 200, {}, [ Thread.current.inspect << "\n" ] ]
+  else
+    raise env.inspect
+  end
+}

data/t/simple-http_Revactor.ru

@@ -1,7 +1,6 @@
 use Rack::ContentLength
 use Rack::ContentType
 run lambda { |env|
-  Actor.sleep 1
   if env['rack.multithread'] == false && env['rainbows.model'] == :Revactor
     [ 200, {}, [ Thread.current.inspect << "\n" ] ]
   else

data/t/simple-http_ThreadPool.ru

@@ -1,7 +1,6 @@
 use Rack::ContentLength
 use Rack::ContentType
 run lambda { |env|
-  sleep 1
   if env['rack.multithread'] && env['rainbows.model'] == :ThreadPool
     [ 200, {}, [ Thread.current.inspect << "\n" ] ]
   else

data/t/simple-http_ThreadSpawn.ru

@@ -1,7 +1,6 @@
 use Rack::ContentLength
 use Rack::ContentType
 run lambda { |env|
-  sleep 1
   if env['rack.multithread'] && env['rainbows.model'] == :ThreadSpawn
     [ 200, {}, [ Thread.current.inspect << "\n" ] ]
   else

data/t/sleep.ru

@@ -7,14 +7,7 @@ run lambda { |env|
   nr = 1
   env["PATH_INFO"] =~ %r{/([\d\.]+)\z} and nr = $1.to_f
 
-  (case env['rainbows.model']
-  when :FiberPool, :FiberSpawn
-    Rainbows::Fiber
-  when :Revactor
-    Actor
-  else
-    Kernel
-  end).sleep(nr)
+  Rainbows.sleep(nr)
 
   [ 200, {'Content-Type' => 'text/plain'}, [ "Hello\n" ] ]
 }

data/t/t9000.ru

@@ -3,14 +3,7 @@ use Rack::ContentType
 use Rainbows::AppPool, :size => ENV['APP_POOL_SIZE'].to_i
 class Sleeper
   def call(env)
-    (case env['rainbows.model']
-    when :FiberPool, :FiberSpawn
-      Rainbows::Fiber
-    when :Revactor
-      Actor
-    else
-      Kernel
-    end).sleep(1)
+    Rainbows.sleep(1)
     [ 200, {}, [ "#{object_id}\n" ] ]
   end
 end

data/t/worker-follows-master-to-death.ru

@@ -6,12 +6,7 @@ run lambda { |env|
 
   case env["PATH_INFO"]
   when %r{/sleep/(\d+)}
-    (case env['rainbows.model']
-    when :Revactor
-      Actor
-    else
-      Kernel
-    end).sleep($1.to_i)
+    Rainbows.sleep($1.to_i)
   end
   [ 200, headers, [ "#$$\n" ] ]
 }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rainbows
 version: !ruby/object:Gem::Version 
-  version: 0.9.0
+  version: 0.90.0
 platform: ruby
 authors: 
 - Rainbows! hackers
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-13 00:00:00 +00:00
+date: 2009-12-22 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -51,6 +51,7 @@ extra_rdoc_files:
 - lib/rainbows/fiber/base.rb
 - lib/rainbows/fiber/io.rb
 - lib/rainbows/fiber/queue.rb
+- lib/rainbows/fiber/rev.rb
 - lib/rainbows/fiber_pool.rb
 - lib/rainbows/fiber_spawn.rb
 - lib/rainbows/http_response.rb
@@ -64,6 +65,7 @@ extra_rdoc_files:
 - lib/rainbows/rev/heartbeat.rb
 - lib/rainbows/rev/master.rb
 - lib/rainbows/rev/thread.rb
+- lib/rainbows/rev_fiber_spawn.rb
 - lib/rainbows/rev_thread_pool.rb
 - lib/rainbows/rev_thread_spawn.rb
 - lib/rainbows/revactor.rb
@@ -118,6 +120,7 @@ files:
 - lib/rainbows/fiber/base.rb
 - lib/rainbows/fiber/io.rb
 - lib/rainbows/fiber/queue.rb
+- lib/rainbows/fiber/rev.rb
 - lib/rainbows/fiber_pool.rb
 - lib/rainbows/fiber_spawn.rb
 - lib/rainbows/http_response.rb
@@ -131,6 +134,7 @@ files:
 - lib/rainbows/rev/heartbeat.rb
 - lib/rainbows/rev/master.rb
 - lib/rainbows/rev/thread.rb
+- lib/rainbows/rev_fiber_spawn.rb
 - lib/rainbows/rev_thread_pool.rb
 - lib/rainbows/rev_thread_spawn.rb
 - lib/rainbows/revactor.rb
@@ -167,6 +171,7 @@ files:
 - t/simple-http_FiberSpawn.ru
 - t/simple-http_NeverBlock.ru
 - t/simple-http_Rev.ru
+- t/simple-http_RevFiberSpawn.ru
 - t/simple-http_RevThreadPool.ru
 - t/simple-http_RevThreadSpawn.ru
 - t/simple-http_Revactor.ru