rainbows 0.6.0 → 0.7.0

data/t/t0009-broken-app.sh

@@ -0,0 +1,56 @@
+#!/bin/sh
+. ./test-lib.sh
+
+t_plan 9 "graceful handling of broken apps for $model"
+
+t_begin "setup and start" && {
+	rainbows_setup $model 1
+	rainbows -D t0009.ru -c $unicorn_config
+	rainbows_wait_start
+}
+
+t_begin "normal response is alright" && {
+	test xOK = x"$(curl -sSf http://$listen/)"
+}
+
+t_begin "app raised exception" && {
+	curl -sSf http://$listen/raise 2> $tmp || :
+	grep -F 500 $tmp
+	> $tmp
+}
+
+t_begin "app exception logged and backtrace not swallowed" && {
+	grep -F 'app error' $r_err
+	grep -A1 -F 'app error' $r_err | tail -1 | grep t0009.ru:
+	dbgcat r_err
+	> $r_err
+}
+
+t_begin "trigger bad response" && {
+	curl -sSf http://$listen/nil 2> $tmp || :
+	grep -F 500 $tmp
+	> $tmp
+}
+
+t_begin "app exception logged" && {
+	grep -F 'app error' $r_err
+	> $r_err
+}
+
+t_begin "normal responses alright afterwards" && {
+	> $tmp
+	curl -sSf http://$listen/ >> $tmp &
+	curl -sSf http://$listen/ >> $tmp &
+	curl -sSf http://$listen/ >> $tmp &
+	curl -sSf http://$listen/ >> $tmp &
+	wait
+	test xOK = x$(sort < $tmp | uniq)
+}
+
+t_begin "teardown" && {
+	kill $rainbows_pid
+}
+
+t_begin "check stderr" && check_stderr
+
+t_done

data/t/t0009.ru

@@ -0,0 +1,13 @@
+#\-E none
+# we do not want Rack::Lint or anything to protect us
+use Rack::ContentLength
+use Rack::ContentType, "text/plain"
+map "/" do
+  run lambda { |env| [ 200, {}, [ "OK\n" ] ] }
+end
+map "/raise" do
+  run lambda { |env| raise "BAD" }
+end
+map "/nil" do
+  run lambda { |env| nil }
+end

data/t/t0010-keepalive-timeout-effective.sh

@@ -0,0 +1,42 @@
+#!/bin/sh
+. ./test-lib.sh
+t_plan 6 "keepalive_timeout tests for $model"
+
+t_begin "setup and start" && {
+	rainbows_setup
+	rainbows -D env.ru -c $unicorn_config
+	rainbows_wait_start
+}
+
+t_begin 'check server up' && {
+	curl -sSf http://$listen/
+}
+
+t_begin "send keepalive response that does not expect close" && {
+	req='GET / HTTP/1.1\r\nHost: example.com\r\n\r\n'
+	t0=$(date +%s)
+	(
+		cat $fifo > $tmp &
+		printf "$req"
+		wait
+		date +%s > $ok
+	) | socat - TCP:$listen > $fifo
+	now="$(cat $ok)"
+	elapsed=$(( $now - $t0 ))
+	t_info "elapsed=$elapsed (expecting >=5s)"
+	test $elapsed -ge 5
+}
+
+t_begin 'keepalive not unreasonably long' && {
+	test $elapsed -lt 15
+}
+
+t_begin "killing succeeds" && {
+	kill $rainbows_pid
+}
+
+t_begin "check stderr" && {
+	check_stderr
+}
+
+t_done

data/t/t0011-close-on-exec-set.sh

@@ -0,0 +1,54 @@
+#!/bin/sh
+nr=${nr-"5"}
+. ./test-lib.sh
+
+t_plan 7 "ensure close-on-exec flag is set for $model"
+
+t_begin "setup and start" && {
+	rainbows_setup $model 1 1
+	nr=$nr rainbows -D fork-sleep.ru -c $unicorn_config
+	rainbows_wait_start
+}
+
+t_begin "send keepalive req expect it to timeout in ~1s" && {
+	req='GET / HTTP/1.1\r\nHost: example.com\r\n\r\n'
+	t0=$(date +%s)
+	(
+		cat $fifo > $tmp &
+		printf "$req"
+		wait
+		date +%s > $ok
+	) | socat - TCP:$listen > $fifo
+	now="$(cat $ok)"
+	elapsed=$(( $now - $t0 ))
+	t_info "elapsed=$elapsed (expecting >=1s)"
+	test $elapsed -ge 1
+}
+
+t_begin 'sleep process is still running' && {
+	sleep_pid="$(tail -1 $tmp)"
+	kill -0 $sleep_pid
+}
+
+t_begin 'keepalive not unreasonably long' && {
+	test $elapsed -lt $nr
+}
+
+t_begin "killing succeeds" && {
+	kill $rainbows_pid
+}
+
+t_begin "check stderr" && {
+	t_info "about to start waiting $nr seconds..."
+	sleep $nr
+	check_stderr
+}
+
+t_begin 'sleep process is NOT running' && {
+	if kill -0 $sleep_pid
+	then
+		die "sleep process should've died"
+	fi
+}
+
+t_done

data/t/t0300-async_sinatra.sh

@@ -5,7 +5,7 @@
 n=10
 CONFIG_RU=async_sinatra.ru
 case $model in
-EventMachine) ;;
+NeverBlock|EventMachine) ;;
 *)
 	t_info "skipping $T since it's not compatible with $model"
 	exit 0

data/t/t9000-rack-app-pool.sh

@@ -1,7 +1,7 @@
 #!/bin/sh
 . ./test-lib.sh
 case $model in
-*Thread*) ;;
+*Thread*|*Fiber*|Revactor|NeverBlock) ;;
 *)
 	t_info "skipping $T since it's not compatible with $model"
 	exit 0

data/t/t9000.ru

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

data/t/test-lib.sh

@@ -80,7 +80,7 @@ check_stderr () {
 	set +u
 	_r_err=${1-${r_err}}
 	set -u
-	if grep Error $_r_err
+	if grep -i Error $_r_err
 	then
 		die "Errors found in $_r_err"
 	elif grep SIGKILL $_r_err
@@ -115,15 +115,25 @@ before_fork do |server, worker|
 end
 EOF
 	{
+		# set a higher default for tests since we run heavily-loaded
+		# boxes and sometimes sleep 1s in tests
+		kato=5
+		echo 'Rainbows! do'
 		if test $# -ge 1
 		then
-			echo 'Rainbows! do'
 			echo "  use :$1"
 			test $# -eq 2 && echo "  worker_connections $2"
-			echo end
+			if test $# -eq 3
+			then
+				echo "  keepalive_timeout $3"
+			else
+				echo "  keepalive_timeout $kato"
+			fi
 		else
-			echo "Rainbows! { use :$model }"
+			echo "  use :$model"
+			echo "  keepalive_timeout $kato"
 		fi
+		echo end
 	} >> $unicorn_config
 }
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rainbows
 version: !ruby/object:Gem::Version 
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors: 
 - Rainbows! hackers
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-15 00:00:00 -08:00
+date: 2009-11-30 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -23,7 +23,7 @@ dependencies:
         version: 0.95.0
     version: 
 description: |-
-  Rainbows! is a HTTP server for sleepy Rack applications.  It is based on
+  Rainbows! is an HTTP server for sleepy Rack applications.  It is based on
   Unicorn, but designed to handle applications that expect long
   request/response times and/or slow clients.  For Rack applications not
   heavily bound by slow external network dependencies, consider Unicorn
@@ -38,15 +38,23 @@ extra_rdoc_files:
 - DEPLOY
 - FAQ
 - lib/rainbows.rb
+- lib/rainbows/actor_spawn.rb
 - lib/rainbows/app_pool.rb
 - lib/rainbows/base.rb
 - lib/rainbows/const.rb
 - lib/rainbows/dev_fd_response.rb
+- lib/rainbows/error.rb
 - lib/rainbows/ev_core.rb
-- lib/rainbows/ev_thread_core.rb
 - lib/rainbows/event_machine.rb
+- lib/rainbows/fiber.rb
+- lib/rainbows/fiber/base.rb
+- lib/rainbows/fiber/io.rb
+- lib/rainbows/fiber/queue.rb
+- lib/rainbows/fiber_pool.rb
+- lib/rainbows/fiber_spawn.rb
 - lib/rainbows/http_response.rb
 - lib/rainbows/http_server.rb
+- lib/rainbows/never_block.rb
 - lib/rainbows/rev.rb
 - lib/rainbows/rev/client.rb
 - lib/rainbows/rev/core.rb
@@ -64,6 +72,7 @@ extra_rdoc_files:
 - TODO
 - TUNING
 - vs_Unicorn
+- Summary
 files: 
 - .document
 - .gitignore
@@ -73,6 +82,8 @@ files:
 - DEPLOY
 - Documentation/.gitignore
 - Documentation/GNUmakefile
+- Documentation/comparison.css
+- Documentation/comparison.haml
 - Documentation/rainbows.1.txt
 - FAQ
 - GIT-VERSION-FILE
@@ -83,19 +94,28 @@ files:
 - README
 - Rakefile
 - SIGNALS
+- Summary
 - TODO
 - TUNING
 - bin/rainbows
 - lib/rainbows.rb
+- lib/rainbows/actor_spawn.rb
 - lib/rainbows/app_pool.rb
 - lib/rainbows/base.rb
 - lib/rainbows/const.rb
 - lib/rainbows/dev_fd_response.rb
+- lib/rainbows/error.rb
 - lib/rainbows/ev_core.rb
-- lib/rainbows/ev_thread_core.rb
 - lib/rainbows/event_machine.rb
+- lib/rainbows/fiber.rb
+- lib/rainbows/fiber/base.rb
+- lib/rainbows/fiber/io.rb
+- lib/rainbows/fiber/queue.rb
+- lib/rainbows/fiber_pool.rb
+- lib/rainbows/fiber_spawn.rb
 - lib/rainbows/http_response.rb
 - lib/rainbows/http_server.rb
+- lib/rainbows/never_block.rb
 - lib/rainbows/rev.rb
 - lib/rainbows/rev/client.rb
 - lib/rainbows/rev/core.rb
@@ -123,6 +143,7 @@ files:
 - t/content-md5.ru
 - t/env.ru
 - t/env_rack_env.ru
+- t/fork-sleep.ru
 - t/heartbeat-timeout.ru
 - t/large-file-response.ru
 - t/my-tap-lib.sh
@@ -130,6 +151,9 @@ files:
 - t/sha1.ru
 - t/simple-http_Base.ru
 - t/simple-http_EventMachine.ru
+- t/simple-http_FiberPool.ru
+- t/simple-http_FiberSpawn.ru
+- t/simple-http_NeverBlock.ru
 - t/simple-http_Rev.ru
 - t/simple-http_RevThreadSpawn.ru
 - t/simple-http_Revactor.ru
@@ -147,6 +171,10 @@ files:
 - t/t0006-process-rack-env.sh
 - t/t0007-worker-follows-master-to-death.sh
 - t/t0008-ensure-usable-after-limit.sh
+- t/t0009-broken-app.sh
+- t/t0009.ru
+- t/t0010-keepalive-timeout-effective.sh
+- t/t0011-close-on-exec-set.sh
 - t/t0100-rack-input-hammer.sh
 - t/t0101-rack-input-trailer.sh
 - t/t0102-rack-input-short.sh

data/lib/rainbows/ev_thread_core.rb

@@ -1,80 +0,0 @@
-# -*- encoding: binary -*-
-require 'thread' # for Queue
-require 'rainbows/ev_core'
-
-module Rainbows
-
-  # base module for mixed Thread + evented models like RevThreadSpawn
-  module EvThreadCore
-    include EvCore
-
-    def post_init
-      super
-      @lock = Mutex.new
-      @thread = nil
-    end
-
-    # we pass ourselves off as a Socket to Unicorn::TeeInput and this
-    # is the only method Unicorn::TeeInput requires from the socket
-    def readpartial(length, buf = "")
-      # we must modify the original buffer if there was one
-      length == 0 and return buf.replace("")
-
-      # wait on the main loop to feed us
-      while @tbuf.size == 0
-        @tbuf.write(@state.pop)
-        resume
-      end
-      buf.replace(@tbuf.read(length))
-    end
-
-    def app_spawn(input)
-      begin
-        @thread.nil? or @thread.join # only one thread per connection
-        env = @env.dup
-        alive, headers = @hp.keepalive?, @hp.headers?
-        @thread = Thread.new(self) do |client|
-          begin
-            env[REMOTE_ADDR] = @remote_addr
-            env[RACK_INPUT] = input || TeeInput.new(client, env, @hp, @buf)
-            response = APP.call(env.update(RACK_DEFAULTS))
-            if 100 == response.first.to_i
-              write(EXPECT_100_RESPONSE)
-              env.delete(HTTP_EXPECT)
-              response = APP.call(env)
-            end
-
-            alive &&= G.alive
-            out = [ alive ? CONN_ALIVE : CONN_CLOSE ] if headers
-            response_write(response, out)
-          rescue => e
-            handle_error(e) rescue nil
-          end
-        end
-        if alive # in case we pipeline
-          @hp.reset
-          redo if @hp.headers(@env.clear, @buf)
-        end
-      end while false
-    end
-
-    def on_read(data)
-      case @state
-      when :headers
-        @hp.headers(@env, @buf << data) or return
-        if 0 == @hp.content_length
-          app_spawn(HttpRequest::NULL_IO) # common case
-        else # nil or len > 0
-          @state, @tbuf = Queue.new, ::IO::Buffer.new
-          app_spawn(nil)
-        end
-      when Queue
-        pause
-        @state << data
-      end
-      rescue => e
-        handle_error(e)
-    end
-
-  end
-end