rainbows 0.7.0 → 0.8.0

data/Documentation/comparison.haml

@@ -85,13 +85,17 @@
     %td.r19 Yes
     %td.rbx No
     %td.slow Yes
+  %tr.comp_row
+    %td.mod RevThreadPool
+    %td.tee No
+    %td.r18 Slow*
+    %td.r19 Yes
+    %td.rbx No
+    %td.slow Yes
 %ul
   %li
-    RevThreadSpawn + 1.8 performance is being improved, follow
-    the
-    %a(href="http://rubyforge.org/mailman/listinfo/rev-talk")
-      rev-talk mailing list
-    for details.
+    RevThread* + 1.8 performance is bad with Rev <= 0.3.1.
+    Rev 0.3.2 (when it is released) should be much faster under 1.8.
   %li
     waiting on Rubinius for better signal handling
   %li
@@ -180,6 +184,13 @@
       %a(href="http://rubyeventmachine.com") EventMachine
     %td.thr No
     %td.reent Yes
+  %tr.comp_row
+    %td.mod RevThreadPool
+    %td.slowio
+      thread-safe Ruby,
+      %a(href="http://rev.rubyforge.org/") Rev
+    %td.thr Yes
+    %td.reent No
 
 %ul
   %li
@@ -276,6 +287,12 @@
     %td.app_pool Yes*
     %td.lock Yes*
     %td.async NeverBlock, async_sinatra
+  %tr.comp_row
+    %td.mod RevThreadPool
+    %td.devfd Yes
+    %td.app_pool Yes
+    %td.lock Dumb
+    %td.async standard Ruby
 
 %ul
   %li

data/GIT-VERSION-GEN

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

data/TODO

@@ -9,9 +9,10 @@ care about.
 
 * EventMachine.spawn - should be like Revactor, maybe?
 
-* {Packet,Rev,EventMachine}+Fibers
+* conditional app.deferred?(env) support
+  Merb uses it, some other servers support it
 
-* {Packet,Rev}ThreadPool
+* {Rev,EventMachine}+Fibers+streaming input
 
 * Rev + callcc - current Rev model with callcc (should work with MBARI)
 

data/lib/rainbows.rb

@@ -8,14 +8,16 @@ module Rainbows
   # global vars because class/instance variables are confusing me :<
   # this struct is only accessed inside workers and thus private to each
   # G.cur may not be used in the network concurrency model
-  class State < Struct.new(:alive,:m,:cur,:kato,:server,:tmp)
+  class State < Struct.new(:alive,:m,:cur,:kato,:server,:tmp,:expire)
     def tick
       tmp.chmod(self.m = m == 0 ? 1 : 0)
+      exit!(2) if expire && Time.now >= expire
       alive && server.master_pid == Process.ppid or quit!
     end
 
     def quit!
       self.alive = false
+      self.expire ||= Time.now + (server.timeout * 2.0)
       server.class.const_get(:LISTENERS).map! { |s| s.close rescue nil }
       false
     end
@@ -78,6 +80,7 @@ module Rainbows
     :ThreadPool => 10,
     :Rev => 50,
     :RevThreadSpawn => 50,
+    :RevThreadPool => 50,
     :EventMachine => 50,
     :FiberSpawn => 50,
     :FiberPool => 50,

data/lib/rainbows/base.rb

@@ -70,11 +70,11 @@ module Rainbows
     end
 
     def join_threads(threads)
-      expire = Time.now + (timeout * 2.0)
-      until threads.empty? || Time.now >= expire
-        threads.delete_if { |thr| thr.alive? ? thr.join(0.01) : true }
-      end
-      exit!(0) unless threads.empty?
+      G.quit!
+      threads.delete_if do |thr|
+        G.tick
+        thr.alive? ? thr.join(0.01) : true
+      end until threads.empty?
     end
 
     def self.included(klass)

data/lib/rainbows/const.rb

@@ -3,7 +3,7 @@
 module Rainbows
 
   module Const
-    RAINBOWS_VERSION = '0.7.0'
+    RAINBOWS_VERSION = '0.8.0'
 
     include Unicorn::Const
 

data/lib/rainbows/rev/master.rb

@@ -0,0 +1,29 @@
+# -*- encoding: binary -*-
+require 'rainbows/rev'
+
+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
+
+  module Rev
+    class Master < ::Rev::AsyncWatcher
+
+      def initialize(queue)
+        super()
+        @queue = queue
+      end
+
+      def <<(output)
+        @queue << output
+        signal
+      end
+
+      def on_signal
+        client, response = @queue.pop
+        client.response_write(response)
+      end
+    end
+  end
+end

data/lib/rainbows/rev/thread.rb

@@ -0,0 +1,53 @@
+# -*- encoding: binary -*-
+require 'thread'
+require 'rainbows/rev/master'
+
+module Rainbows
+  module Rev
+
+    class ThreadClient < Client
+
+      def app_call
+        KATO.delete(self)
+        disable
+        @env[RACK_INPUT] = @input
+        @input = nil # not sure why, @input seems to get closed otherwise...
+        app_dispatch # must be implemented by subclass
+      end
+
+      # this is only called in the master thread
+      def response_write(response)
+        enable
+        alive = @hp.keepalive? && G.alive
+        out = [ alive ? CONN_ALIVE : CONN_CLOSE ] if @hp.headers?
+        DeferredResponse.write(self, response, out)
+        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
+
+      # 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
+
+    end
+  end
+end

data/lib/rainbows/rev_thread_pool.rb

@@ -0,0 +1,75 @@
+# -*- encoding: binary -*-
+require 'rainbows/rev/thread'
+
+module Rainbows
+
+  # A combination of the Rev and ThreadPool models.  This allows Ruby
+  # 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.
+  #
+  # Unlike ThreadPool, Rev makes this model highly suitable for
+  # slow clients and applications with medium-to-slow response times
+  # (I/O bound), but less suitable for sleepy applications.
+  #
+  # WARNING: this model does not currently perform well under 1.8 with
+  # Rev 0.3.1.  Rev 0.3.2 should include significant performance
+  # improvements under Ruby 1.8.
+
+  module RevThreadPool
+
+    DEFAULTS = {
+      :pool_size => 10, # same default size as ThreadPool (w/o Rev)
+    }
+
+    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"
+    end
+
+    class PoolWatcher < ::Rev::TimerWatcher
+      def initialize(threads)
+        @threads = threads
+        super(G.server.timeout, true)
+      end
+
+      def on_timer
+        @threads.each { |t| t.join(0) and G.quit! }
+      end
+    end
+
+    class Client < Rainbows::Rev::ThreadClient
+      def app_dispatch
+        QUEUE << self
+      end
+    end
+
+    include Rainbows::Rev::Core
+
+    def init_worker_threads(master, queue)
+      O[:pool_size].times.map do
+        Thread.new do
+          begin
+            client = queue.pop
+            master << [ client, client.app_response ]
+          rescue => e
+            Error.listen_loop(e)
+          end while true
+        end
+      end
+    end
+
+    def init_worker_process(worker)
+      super
+      master = Rev::Master.new(Queue.new).attach(::Rev::Loop.default)
+      queue = Client.const_set(:QUEUE, Queue.new)
+      threads = init_worker_threads(master, queue)
+      PoolWatcher.new(threads).attach(::Rev::Loop.default)
+      logger.info "RevThreadPool pool_size=#{O[:pool_size]}"
+    end
+  end
+end

data/lib/rainbows/rev_thread_spawn.rb

@@ -1,9 +1,5 @@
 # -*- encoding: binary -*-
-require 'rainbows/rev'
-
-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"
+require 'rainbows/rev/thread'
 
 module Rainbows
 
@@ -15,73 +11,19 @@ module Rainbows
   # server are handled by the main thread and outside of the core
   # application dispatch.
   #
-  # 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/].
+  # Unlike ThreadSpawn, Rev makes this model highly suitable for
+  # slow clients and applications with medium-to-slow response times
+  # (I/O bound), but less suitable for sleepy applications.
+  #
+  # WARNING: this model does not currently perform well under 1.8 with
+  # Rev 0.3.1.  Rev 0.3.2 should include significant performance
+  # improvements under Ruby 1.8.
 
   module RevThreadSpawn
 
-    class Master < ::Rev::AsyncWatcher
-
-      def initialize
-        super
-        @queue = Queue.new
-      end
-
-      def <<(output)
-        @queue << output
-        signal
-      end
-
-      def on_signal
-        client, response = @queue.pop
-        client.response_write(response)
-      end
-    end
-
-    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)
-        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
-
-      # 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 ] }
+    class Client < Rainbows::Rev::ThreadClient
+      def app_dispatch
+        Thread.new(self) { |client| MASTER << [ client, app_response ] }
       end
     end
 
@@ -89,7 +31,8 @@ module Rainbows
 
     def init_worker_process(worker)
       super
-      Client.const_set(:MASTER, Master.new.attach(::Rev::Loop.default))
+      master = Rev::Master.new(Queue.new).attach(::Rev::Loop.default)
+      Client.const_set(:MASTER, master)
     end
 
   end

data/lib/rainbows/revactor.rb

@@ -78,42 +78,46 @@ module Rainbows
     def worker_loop(worker)
       init_worker_process(worker)
       RD_ARGS[:timeout] = G.kato if G.kato > 0
-
-      root = Actor.current
-      root.trap_exit = true
-
+      nr = 0
       limit = worker_connections
-      revactorize_listeners!
-      clients = {}
+      actor_exit = Case[:exit, Actor, Object]
 
-      listeners = LISTENERS.map do |s|
-        Actor.spawn(s) do |l|
+      revactorize_listeners.each do |l, close, accept|
+        Actor.spawn(l, close, accept) do |l, close, accept|
+          Actor.current.trap_exit = true
+          l.controller = l.instance_eval { @receiver = Actor.current }
           begin
-            while clients.size >= limit
-              logger.info "busy: clients=#{clients.size} >= limit=#{limit}"
-              Actor.receive { |filter| filter.when(:resume) {} }
+            while nr >= limit
+              l.disable if l.enabled?
+              logger.info "busy: clients=#{nr} >= limit=#{limit}"
+              Actor.receive do |f|
+                f.when(close) {}
+                f.when(actor_exit) { nr -= 1 }
+                f.after(0.01) {} # another listener could've gotten an exit
+              end
+            end
+
+            l.enable unless l.enabled?
+            Actor.receive do |f|
+              f.when(close) {}
+              f.when(actor_exit) { nr -= 1 }
+              f.when(accept) do |_, _, s|
+                nr += 1
+                Actor.spawn_link(s) { |c| process_client(c) }
+              end
             end
-            actor = Actor.spawn(l.accept) { |c| process_client(c) }
-            clients[actor.object_id] = actor
-            root.link(actor)
-          rescue Errno::EAGAIN, Errno::ECONNABORTED
           rescue => e
             Error.listen_loop(e)
           end while G.alive
+          Actor.receive do |f|
+            f.when(close) {}
+            f.when(actor_exit) { nr -= 1 }
+          end while nr > 0
         end
       end
 
-      begin
-        Actor.receive do |filter|
-          filter.after(1) { G.tick }
-          filter.when(Case[:exit, Actor, Object]) do |_,actor,_|
-            orig = clients.size
-            clients.delete(actor.object_id)
-            orig >= limit and listeners.each { |l| l << :resume }
-            G.tick
-          end
-        end
-      end while G.alive || clients.size > 0
+      Actor.sleep 1 while G.tick || nr > 0
+      rescue Errno::EMFILE => e
     end
 
     # if we get any error, try to write something back to the client
@@ -127,13 +131,17 @@ module Rainbows
       rescue
     end
 
-    def revactorize_listeners!
-      LISTENERS.map! do |s|
+    def revactorize_listeners
+      LISTENERS.map do |s|
         case s
         when TCPServer
-          ::Revactor::TCP.listen(s, nil)
+          l = ::Revactor::TCP.listen(s, nil)
+          [ l, T[:tcp_closed, ::Revactor::TCP::Socket],
+            T[:tcp_connection, l, ::Revactor::TCP::Socket] ]
         when UNIXServer
-          ::Revactor::UNIX.listen(s)
+          l = ::Revactor::UNIX.listen(s)
+          [ l, T[:unix_closed, ::Revactor::UNIX::Socket ],
+            T[:unix_connection, l, ::Revactor::UNIX::Socket] ]
         end
       end
     end

data/t/GNUmakefile

@@ -32,6 +32,7 @@ ifeq ($(ONENINE),true)
 
   # technically this works under 1.8, but wait until rev 0.3.2
   models += RevThreadSpawn
+  models += RevThreadPool
 endif
 all_models := $(models) Base
 

data/t/simple-http_RevThreadPool.ru

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rainbows
 version: !ruby/object:Gem::Version 
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors: 
 - Rainbows! hackers
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-30 00:00:00 +00:00
+date: 2009-12-02 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -60,6 +60,9 @@ extra_rdoc_files:
 - lib/rainbows/rev/core.rb
 - lib/rainbows/rev/deferred_response.rb
 - lib/rainbows/rev/heartbeat.rb
+- lib/rainbows/rev/master.rb
+- lib/rainbows/rev/thread.rb
+- lib/rainbows/rev_thread_pool.rb
 - lib/rainbows/rev_thread_spawn.rb
 - lib/rainbows/revactor.rb
 - lib/rainbows/revactor/tee_input.rb
@@ -67,6 +70,7 @@ extra_rdoc_files:
 - lib/rainbows/thread_spawn.rb
 - LICENSE
 - NEWS
+- rainbows.1
 - README
 - SIGNALS
 - TODO
@@ -121,6 +125,9 @@ files:
 - lib/rainbows/rev/core.rb
 - lib/rainbows/rev/deferred_response.rb
 - lib/rainbows/rev/heartbeat.rb
+- lib/rainbows/rev/master.rb
+- lib/rainbows/rev/thread.rb
+- lib/rainbows/rev_thread_pool.rb
 - lib/rainbows/rev_thread_spawn.rb
 - lib/rainbows/revactor.rb
 - lib/rainbows/revactor/tee_input.rb
@@ -155,6 +162,7 @@ files:
 - t/simple-http_FiberSpawn.ru
 - t/simple-http_NeverBlock.ru
 - t/simple-http_Rev.ru
+- t/simple-http_RevThreadPool.ru
 - t/simple-http_RevThreadSpawn.ru
 - t/simple-http_Revactor.ru
 - t/simple-http_ThreadPool.ru
@@ -186,6 +194,7 @@ files:
 - t/test-lib.sh
 - t/worker-follows-master-to-death.ru
 - vs_Unicorn
+- rainbows.1
 has_rdoc: true
 homepage: http://rainbows.rubyforge.org/
 licenses: []