rainbows 0.6.0 → 0.7.0

data/lib/rainbows/revactor.rb

@@ -23,21 +23,30 @@ module Rainbows
   module Revactor
     require 'rainbows/revactor/tee_input'
 
+    RD_ARGS = {}
+
     include Base
 
     # once a client is accepted, it is processed in its entirety here
     # in 3 easy steps: read request, call app, write app response
     def process_client(client)
-      buf = client.read or return # this probably does not happen...
+      defined?(Fcntl::FD_CLOEXEC) and
+        client.instance_eval { @_io.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC) }
+      rd_args = [ nil ]
+      remote_addr = if ::Revactor::TCP::Socket === client
+        rd_args << RD_ARGS
+        client.remote_addr
+      else
+        LOCALHOST
+      end
+      buf = client.read(*rd_args)
       hp = HttpParser.new
       env = {}
       alive = true
-      remote_addr = ::Revactor::TCP::Socket === client ?
-                    client.remote_addr : LOCALHOST
 
       begin
         while ! hp.headers(env, buf)
-          buf << client.read
+          buf << client.read(*rd_args)
         end
 
         env[Const::RACK_INPUT] = 0 == hp.content_length ?
@@ -56,9 +65,11 @@ module Rainbows
         out = [ alive ? CONN_ALIVE : CONN_CLOSE ] if hp.headers?
         HttpResponse.write(client, response, out)
       end while alive and hp.reset.nil? and env.clear
-      client.close
+    rescue ::Revactor::TCP::ReadError
     rescue => e
       handle_error(client, e)
+    ensure
+      client.close
     end
 
     # runs inside each forked worker, this sits around and waits
@@ -66,6 +77,7 @@ module Rainbows
     # given a INT, QUIT, or TERM signal)
     def worker_loop(worker)
       init_worker_process(worker)
+      RD_ARGS[:timeout] = G.kato if G.kato > 0
 
       root = Actor.current
       root.trap_exit = true
@@ -85,8 +97,8 @@ module Rainbows
             clients[actor.object_id] = actor
             root.link(actor)
           rescue Errno::EAGAIN, Errno::ECONNABORTED
-          rescue Object => e
-            listen_loop_error(e)
+          rescue => e
+            Error.listen_loop(e)
           end while G.alive
         end
       end
@@ -109,23 +121,10 @@ module Rainbows
     # 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)
-      msg = case e
-      when EOFError,Errno::ECONNRESET,Errno::EPIPE,Errno::EINVAL,Errno::EBADF
-        Const::ERROR_500_RESPONSE
-      when HttpParserError # try to tell the client they're bad
-        Const::ERROR_400_RESPONSE
-      else
-        logger.error "Read error: #{e.inspect}"
-        logger.error e.backtrace.join("\n")
-        Const::ERROR_500_RESPONSE
-      end
-      client.instance_eval do
-        # this is Revactor implementation dependent
-        @_io.write_nonblock(msg)
-        close
-      end
+      # this is Revactor implementation dependent
+      msg = Error.response(e) and
+        client.instance_eval { @_io.write_nonblock(msg) }
       rescue
-        nil
     end
 
     def revactorize_listeners!

data/lib/rainbows/thread_pool.rb

@@ -27,42 +27,44 @@ module Rainbows
 
     def worker_loop(worker)
       init_worker_process(worker)
-      pool = (1..worker_connections).map { new_worker_thread }
+      pool = (1..worker_connections).map do
+        Thread.new { LISTENERS.size == 1 ? sync_worker : async_worker }
+      end
 
       while G.alive
         # if any worker dies, something is serious wrong, bail
         pool.each do |thr|
-          G.tick
+          G.tick or break
           thr.join(1) and G.quit!
         end
       end
       join_threads(pool)
     end
 
-    def new_worker_thread
-      Thread.new {
-        begin
-          begin
-            # TODO: check if select() or accept() is a problem on large
-            # SMP systems under Ruby 1.9.  Hundreds of native threads
-            # all working off the same socket could be a thundering herd
-            # problem.  On the other hand, a thundering herd may not
-            # even incur as much overhead as an extra Mutex#synchronize
-            ret = IO.select(LISTENERS, nil, nil, 1) and
-                  ret.first.each do |sock|
-                    begin
-                      process_client(sock.accept_nonblock)
-                    rescue Errno::EAGAIN, Errno::ECONNABORTED
-                    end
-                  end
-          rescue Errno::EINTR
-          rescue Errno::EBADF, TypeError
-            break
-          end
-        rescue Object => e
-          listen_loop_error(e)
-        end while G.alive
-      }
+    def sync_worker
+      s = LISTENERS.first
+      begin
+        process_client(s.accept)
+      rescue Errno::EINTR, Errno::ECONNABORTED
+      rescue => e
+        Error.listen_loop(e)
+      end while G.alive
+    end
+
+    def async_worker
+      begin
+        # TODO: check if select() or accept() is a problem on large
+        # SMP systems under Ruby 1.9.  Hundreds of native threads
+        # all working off the same socket could be a thundering herd
+        # problem.  On the other hand, a thundering herd may not
+        # even incur as much overhead as an extra Mutex#synchronize
+        ret = IO.select(LISTENERS, nil, nil, 1) and ret.first.each do |s|
+          s = Rainbows.accept(s) and process_client(s)
+        end
+      rescue Errno::EINTR
+      rescue => e
+        Error.listen_loop(e)
+      end while G.alive
     end
 
   end

data/lib/rainbows/thread_spawn.rb

@@ -1,4 +1,5 @@
 # -*- encoding: binary -*-
+require 'thread'
 module Rainbows
 
   # Spawns a new thread for every client connection we accept().  This
@@ -19,43 +20,42 @@ module Rainbows
 
     include Base
 
-    def worker_loop(worker)
-      init_worker_process(worker)
-      threads = ThreadGroup.new
+    def accept_loop(klass)
+      lock = Mutex.new
       limit = worker_connections
-
-      begin
-        ret = begin
-          G.tick or break
-          IO.select(LISTENERS, nil, nil, 1) or next
-        rescue Errno::EINTR
-          retry
-        rescue Errno::EBADF, TypeError
-          break
-        end
-        G.tick
-
-        ret.first.each do |l|
-          # Sleep if we're busy, another less busy worker process may
-          # take it for us if we sleep. This is gross but other options
-          # still suck because they require expensive/complicated
-          # synchronization primitives for _every_ case, not just this
-          # unlikely one.  Since this case is (or should be) uncommon,
-          # just busy wait when we have to.
-          while threads.list.size > limit # unlikely
-            sleep(0.1) # hope another process took it
-            break # back to IO.select
-          end
+      LISTENERS.each do |l|
+        klass.new(l) do |l|
           begin
-            threads.add(Thread.new(l.accept_nonblock) {|c| process_client(c) })
-          rescue Errno::EAGAIN, Errno::ECONNABORTED
-          end
+            if lock.synchronize { G.cur >= limit }
+              # Sleep if we're busy, another less busy worker process may
+              # take it for us if we sleep. This is gross but other options
+              # still suck because they require expensive/complicated
+              # synchronization primitives for _every_ case, not just this
+              # unlikely one.  Since this case is (or should be) uncommon,
+              # just busy wait when we have to.
+              sleep(0.01)
+            else
+              klass.new(l.accept) do |c|
+                begin
+                  lock.synchronize { G.cur += 1 }
+                  process_client(c)
+                ensure
+                  lock.synchronize { G.cur -= 1 }
+                end
+              end
+            end
+          rescue Errno::EINTR, Errno::ECONNABORTED
+          rescue => e
+            Error.listen_loop(e)
+          end while G.alive
         end
-      rescue Object => e
-        listen_loop_error(e)
-      end while true
-      join_threads(threads.list)
+      end
+      sleep 1 while G.tick || lock.synchronize { G.cur > 0 }
     end
 
+    def worker_loop(worker)
+      init_worker_process(worker)
+      accept_loop(Thread)
+    end
   end
 end

data/local.mk.sample

@@ -4,12 +4,15 @@
 #
 # This is depends on a bunch of GNU-isms from bash, sed, touch.
 
+RSYNC = rsync
 DLEXT := so
 gems := rack-1.0.1
-# gems += unicorn-0.95.0 # installed via setup.rb
-gems += rev-0.3.1 iobuffer-0.1.1
+# gems += unicorn-0.95.1 # installed via setup.rb
+gems += rev-0.3.1 # up to 0.3.2 once it's out for 1.8
+gems += iobuffer-0.1.3
 gems += eventmachine-0.12.10
 gems += async_sinatra-0.1.5 sinatra-0.9.4
+gems += espace-neverblock-0.1.6.1
 
 # Avoid loading rubygems to speed up tests because gmake is
 # fork+exec heavy with Ruby.
@@ -51,20 +54,19 @@ latest: NEWS
 # publishes docs to http://rainbows.rubyforge.org
 publish_doc:
 	-git set-file-times
-	$(RM) -r doc
-	$(MAKE) doc
+	$(RM) -r doc ChangeLog NEWS
+	$(MAKE) doc LOG_VERSION=$(shell git tag -l | tail -1)
 	$(MAKE) -s latest > doc/LATEST
 	find doc/images doc/js -type f | \
 		TZ=UTC xargs touch -d '1970-01-01 00:00:00' doc/rdoc.css
 	$(MAKE) doc_gz
 	chmod 644 $$(find doc -type f)
-	rsync -av --delete doc/ \
-	  rubyforge.org:/var/www/gforge-projects/rainbows/
+	$(RSYNC) -av doc/ rubyforge.org:/var/www/gforge-projects/rainbows/
+	$(RSYNC) -av doc/ dcvr:/srv/rainbows/
 	git ls-files | xargs touch
 
 # Create gzip variants of the same timestamp as the original so nginx
 # "gzip_static on" can serve the gzipped versions directly.
-doc_gz: suf := html js css
 doc_gz: docs = $(shell find doc -type f ! -regex '^.*\.\(gif\|jpg\|png\|gz\)$$')
 doc_gz:
 	touch doc/NEWS.atom.xml -d "$$(awk 'NR==1{print $$4,$$5,$$6}' NEWS)"

data/rainbows.gemspec

@@ -54,10 +54,16 @@ Gem::Specification.new do |s|
   # s.add_dependency(%q<revactor>, [">= 0.1.5"])
   #
   # Revactor depends on Rev, too, 0.3.0 got the ability to attach IOs
-  # s.add_dependency(%q<rev>, [">= 0.3.0"])
+  # s.add_dependency(%q<rev>, [">= 0.3.1"])
+  #
+  # Rev depends on IOBuffer, which got faster in 0.1.3
+  # s.add_dependency(%q<iobuffer>, [">= 0.1.3"])
   #
   # We use the new EM::attach/watch API in 0.12.10
   # s.add_dependency(%q<eventmachine>, ["~> 0.12.10"])
+  #
+  # NeverBlock, currently only available on http://gems.github.com/
+  # s.add_dependency(%q<espace-neverblock>, ["~> 0.1.6.1"])
 
-  # s.licenses = %w(GPLv2 Ruby) # accessor not compatible with older Rubygems
+  # s.licenses = %w(GPLv2 Ruby) # accessor not compatible with older RubyGems
 end

data/t/GNUmakefile

@@ -4,13 +4,17 @@ all::
 
 pid := $(shell echo $$PPID)
 
-RUBY = $(ruby)
+RUBY = ruby
 rainbows_lib := $(shell cd ../lib && pwd)
 -include ../local.mk
 ifeq ($(RUBY_VERSION),)
   RUBY_VERSION := $(shell $(RUBY) -e 'puts RUBY_VERSION')
 endif
 
+ifeq ($(RUBY_VERSION),)
+  $(error unable to detect RUBY_VERSION)
+endif
+
 ifeq ($(RUBYLIB),)
   RUBYLIB := $(rainbows_lib)
 else
@@ -18,10 +22,16 @@ else
 endif
 export RUBYLIB RUBY_VERSION
 
-models := ThreadPool ThreadSpawn Rev EventMachine
-models += RevThreadSpawn
-ifeq ($(RUBY_VERSION),1.9.1) # 1.9.2-preview1 was broken
+models = ThreadPool ThreadSpawn Rev EventMachine NeverBlock
+rp := )
+ONENINE := $(shell case $(RUBY_VERSION) in 1.9.*$(rp) echo true;;esac)
+ifeq ($(ONENINE),true)
   models += Revactor
+  models += FiberSpawn
+  models += FiberPool
+
+  # technically this works under 1.8, but wait until rev 0.3.2
+  models += RevThreadSpawn
 endif
 all_models := $(models) Base
 
@@ -37,9 +47,6 @@ t0002-graceful.sh: MODELS = $(all_models)
 t0002-parser-error.sh: MODELS = $(all_models)
 t0003-reopen-logs.sh: MODELS = $(all_models)
 
-# this test is not compatible with non-Thread models yet
-t9000-rack-app-pool.sh: MODELS = ThreadPool ThreadSpawn
-
 # recursively run per-model tests
 # haven't figured out a good way to make make non-recursive here, yet...
 $(T):

data/t/fork-sleep.ru

@@ -0,0 +1,10 @@
+#\-E none
+# we do not want Rack::Lint or anything to protect us
+use Rack::ContentLength
+use Rack::ContentType, "text/plain"
+trap(:CHLD) { $stderr.puts Process.waitpid2(-1).inspect }
+map "/" do
+  time = ENV["nr"] || '15'
+  pid = fork { exec('sleep', time) }
+  run lambda { |env| [ 200, {}, [ "#{pid}\n" ] ] }
+end

data/t/simple-http_FiberPool.ru

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

data/t/simple-http_FiberSpawn.ru

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

data/t/simple-http_NeverBlock.ru

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

data/t/sleep.ru

@@ -8,6 +8,8 @@ run lambda { |env|
   env["PATH_INFO"] =~ %r{/([\d\.]+)\z} and nr = $1.to_f
 
   (case env['rainbows.model']
+  when :FiberPool, :FiberSpawn
+    Rainbows::Fiber
   when :Revactor
     Actor
   else

data/t/t0000-simple-http.sh

@@ -1,6 +1,6 @@
 #!/bin/sh
 . ./test-lib.sh
-t_plan 24 "simple HTTP connection keepalive/pipelining tests for $model"
+t_plan 25 "simple HTTP connection keepalive/pipelining tests for $model"
 
 t_begin "checking for config.ru for $model" && {
 	tbase=simple-http_$model.ru
@@ -21,6 +21,17 @@ t_begin "single request" && {
 	curl -sSfv http://$listen/
 }
 
+t_begin "handles client EOF gracefully" && {
+	printf 'GET / HTTP/1.1\r\nHost: example.com\r\n\r\n' | \
+		socat - TCP4:$listen > $tmp
+	dbgcat tmp
+	if grep 'HTTP.* 500' $tmp
+	then
+		die "500 error returned on client shutdown(SHUT_WR)"
+	fi
+	check_stderr
+}
+
 dbgcat r_err
 
 t_begin "two requests with keepalive" && {

data/t/t0001-unix-http.sh

@@ -1,6 +1,6 @@
 #!/bin/sh
 . ./test-lib.sh
-t_plan 18 "simple HTTP connection keepalive/pipelining tests for $model"
+t_plan 19 "simple HTTP connection keepalive/pipelining tests for $model"
 
 t_begin "checking for config.ru for $model" && {
 	tbase=simple-http_$model.ru
@@ -23,6 +23,17 @@ t_begin "single TCP request" && {
 	curl -sSfv http://$listen/
 }
 
+t_begin "handles client EOF gracefully" && {
+	printf 'GET / HTTP/1.1\r\nHost: example.com\r\n\r\n' | \
+		socat - UNIX:$unix_socket > $tmp
+	dbgcat tmp
+	if grep 'HTTP.* 500' $tmp
+	then
+		die "500 error returned on client shutdown(SHUT_WR)"
+	fi
+	check_stderr
+}
+
 dbgcat r_err
 
 t_begin "pipelining partial requests" && {