rainbows 2.0.1 → 2.1.0

data/t/GNUmakefile

@@ -23,10 +23,9 @@ models += WriterThreadPool
 models += WriterThreadSpawn
 models += ThreadPool
 models += ThreadSpawn
-models += Rev
+models += Coolio
 models += EventMachine
 models += NeverBlock
-models += RevThreadSpawn
 
 ifeq ($(RUBY_ENGINE),ruby)
   rp := )
@@ -34,9 +33,10 @@ ifeq ($(RUBY_ENGINE),ruby)
   ifeq ($(ONENINE),true)
     models += Revactor
     models += FiberSpawn
-    models += RevFiberSpawn
     models += FiberPool
-    models += RevThreadPool
+    models += CoolioThreadPool
+    models += CoolioThreadSpawn
+    models += CoolioFiberSpawn
   endif
 endif
 

data/t/close-has-env.ru

@@ -0,0 +1,65 @@
+#\ -E none
+use Rainbows::DevFdResponse
+class ClosablePipe < ::IO
+  attr_accessor :env
+
+  def self.new(env)
+    rv = popen "echo hello", "rb"
+    rv.env = env
+    rv
+  end
+
+  def close
+    super
+    $stdout.syswrite "path_info=#{@env['PATH_INFO']}\n"
+  end
+end
+
+class ClosableFile < ::File
+  attr_accessor :env
+  alias to_path path
+  def close
+    super
+    $stdout.syswrite "path_info=#{@env['PATH_INFO']}\n"
+  end
+end
+
+class Blob
+  def initialize(env)
+    @env = env
+  end
+
+  def each(&block)
+    yield "BLOB\n"
+  end
+
+  def close
+    $stdout.syswrite "path_info=#{@env['PATH_INFO']}\n"
+  end
+end
+
+run(lambda { |env|
+  case env["PATH_INFO"]
+  when %r{\A/pipe/}
+    [ 200,
+      [ %w(Content-Length 6), %w(Content-Type text/plain)],
+      ClosablePipe.new(env)
+    ]
+  when %r{\A/file/}
+    f = ClosableFile.open("env.ru", "rb")
+    f.env = env
+    [ 200, {
+      'X-Req-Path' => env["PATH_INFO"],
+      'Content-Length' => f.stat.size.to_s,
+      'Content-Type' => 'text/plain' },
+      f
+    ]
+  when %r{\A/blob/}
+    [ 200,
+      [%w(Content-Length 5), %w(Content-Type text/plain)],
+      Blob.new(env)
+    ]
+  else
+    [ 404, [%w(Content-Length 0), %w(Content-Type text/plain)], [] ]
+  end
+})

data/t/simple-http_Coolio.ru

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

data/t/simple-http_CoolioFiberSpawn.ru

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

data/t/simple-http_CoolioThreadPool.ru

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

data/t/simple-http_CoolioThreadSpawn.ru

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

data/t/t0004-heartbeat-timeout.sh

@@ -5,8 +5,8 @@ t_plan 12 "heartbeat/timeout test for $model"
 
 t_begin "setup and startup" && {
 	rainbows_setup $model
-        echo timeout 3 >> $unicorn_config
-        echo preload_app true >> $unicorn_config
+	echo timeout 3 >> $unicorn_config
+	echo preload_app true >> $unicorn_config
 	rainbows -D heartbeat-timeout.ru -c $unicorn_config
 	rainbows_wait_start
 }

data/t/t0007-worker-follows-master-to-death.sh

@@ -5,7 +5,7 @@ t_plan 7 "ensure worker follows master to death"
 t_begin "setup" && {
 	rtmpfiles curl_err curl_out
 	rainbows_setup
-        echo timeout 3 >> $unicorn_config
+	echo timeout 3 >> $unicorn_config
 	rainbows -D -c $unicorn_config worker-follows-master-to-death.ru
 	rainbows_wait_start
 }

data/t/t0015-working_directory.sh

@@ -6,7 +6,7 @@ then
 fi
 . ./test-lib.sh
 
-t_plan 5 "config.ru inside alt working_directory"
+t_plan 6 "config.ru inside alt working_directory"
 
 t_begin "setup and start" && {
 	rainbows_setup
@@ -41,6 +41,12 @@ EOF
 	rainbows_wait_start
 }
 
+t_begin "reload to avoid race condition" && {
+	curl -sSf http://$listen/ >/dev/null
+	kill -HUP $rainbows_pid
+	test xSTART = x"$(cat $fifo)"
+}
+
 t_begin "hit with curl" && {
 	body=$(curl -sSf http://$listen/)
 }

data/t/t0017-keepalive-timeout-zero.sh

@@ -4,7 +4,7 @@ t_plan 6 "keepalive_timeout 0 tests for $model"
 
 t_begin "setup and start" && {
 	rainbows_setup $model 2 0
-        grep 'keepalive_timeout 0' $unicorn_config
+	grep 'keepalive_timeout 0' $unicorn_config
 	rainbows -D env.ru -c $unicorn_config
 	rainbows_wait_start
 }

data/t/t0019-keepalive-cpu-usage.sh

@@ -0,0 +1,62 @@
+#!/bin/sh
+if test -z "$V" || test 0 -eq "$V"
+then
+	exit 0
+fi
+. ./test-lib.sh
+skip_models WriterThreadSpawn WriterThreadPool Base
+t_plan 6 "keepalive_timeout CPU usage tests for $model"
+
+t_begin "setup and start" && {
+	rainbows_setup $model 50 666
+	grep 'worker_connections 50' $unicorn_config
+	grep 'keepalive_timeout 666' $unicorn_config
+	rainbows -E deployment -D times.ru -c $unicorn_config
+	rainbows_wait_start
+}
+
+t_begin 'read current times' && {
+	eval "$(curl -sSf http://$listen/)"
+	before_utime=$utime
+	before_stime=$stime
+	echo "utime=$utime stime=$stime"
+}
+
+t_begin 'keepalive connections' && {
+	listen=$listen $RUBY -rsocket -e '
+host, port = ENV["listen"].split(/:/)
+port = port.to_i
+socks = (1..49).map do |i|
+  s = TCPSocket.new(host, port)
+  # need to write something to get around deferred accepts
+  s.write "GET /#{i} HTTP/1.1\r\nHost: example.com\r\n\r\n"
+  s.readpartial 16384
+  s
+end
+sleep
+	' &
+	ruby_pid=$!
+	for i in $(awk 'BEGIN { for(i=0;i<60;++i) print i }' </dev/null)
+	do
+		sleep 1
+		eval "$(curl -sSf http://$listen/)"
+		echo "utime[$i] $before_utime => $utime" \
+		     "stime[$i] $before_stime => $stime"
+	done
+	kill $ruby_pid
+}
+
+t_begin "times not unreasonable" && {
+	echo "utime: $before_utime => $utime" \
+	     "stime: $before_stime => $stime"
+}
+
+t_begin "killing succeeds" && {
+	kill $rainbows_pid
+}
+
+t_begin "check stderr" && {
+	check_stderr
+}
+
+t_done

data/t/t0040-keepalive_requests-setting.sh

@@ -0,0 +1,51 @@
+#!/bin/sh
+. ./test-lib.sh
+t_plan 6 "keepalive_requests limit tests for $model"
+
+t_begin "setup and start" && {
+	rainbows_setup $model 50 666
+	rtmpfiles curl_out curl_err
+	grep 'keepalive_timeout 666' $unicorn_config
+        ed -s $unicorn_config <<EOF
+,s/listen.*/&, :tcp_nodelay => true/
+w
+EOF
+	grep nodelay $unicorn_config
+	rainbows -E none -D env.ru -c $unicorn_config
+	rainbows_wait_start
+}
+
+t_begin "curl requests hit default keepalive_requests limit" && {
+	curl -sSfv http://$listen/[0-101] > $curl_out 2> $curl_err
+	test 1 -eq $(grep 'Connection: close' $curl_err |wc -l)
+	test 101 -eq $(grep 'Connection: keep-alive' $curl_err |wc -l)
+}
+
+t_begin "reload with smaller keepalive_requests limit" && {
+	ed -s $unicorn_config <<EOF
+,g/Rainbows!/
+a
+  keepalive_requests 5
+.
+w
+EOF
+	kill -HUP $rainbows_pid
+	test x"$(cat $fifo)" = xSTART
+}
+
+t_begin "curl requests hit smaller keepalive_requests limit" && {
+	rm -f $curl_out $curl_err
+	curl -sSfv http://$listen/[1-13] > $curl_out 2> $curl_err
+	test 2 -eq $(grep 'Connection: close' $curl_err |wc -l)
+	test 11 -eq $(grep 'Connection: keep-alive' $curl_err |wc -l)
+}
+
+t_begin "killing succeeds" && {
+	kill $rainbows_pid
+}
+
+t_begin "check stderr" && {
+	check_stderr
+}
+
+t_done

data/t/t0050-response-body-close-has-env.sh

@@ -0,0 +1,109 @@
+#!/bin/sh
+. ./test-lib.sh
+
+t_plan 29 "keepalive does not clear Rack env prematurely for $model"
+
+t_begin "setup and start" && {
+	rainbows_setup
+	rtmpfiles curl_out curl_err
+	echo "preload_app true" >> $unicorn_config
+	rainbows -D close-has-env.ru -c $unicorn_config
+	rainbows_wait_start
+}
+
+req_pipelined () {
+	pfx=$1
+	t_begin "make pipelined requests to trigger $pfx response body" && {
+		> $r_out
+		(
+			cat $fifo > $tmp &
+			printf 'GET /%s/1 HTTP/1.1\r\n' $pfx
+			printf 'Host: example.com\r\n\r\n'
+			printf 'GET /%s/2 HTTP/1.1\r\n' $pfx
+			printf 'Host: example.com\r\n\r\n'
+			printf 'GET /%s/3 HTTP/1.1\r\n' $pfx
+			printf 'Host: example.com\r\n'
+			printf 'Connection: close\r\n\r\n'
+			wait
+			echo ok > $ok
+		) | socat - TCP4:$listen > $fifo
+		test xok = x$(cat $ok)
+	}
+}
+
+reload () {
+	t_begin 'reloading Rainbows! to ensure writeout' && {
+		# reload to ensure everything is flushed
+		kill -HUP $rainbows_pid
+		test xSTART = x"$(cat $fifo)"
+	}
+}
+
+check_log () {
+	pfx="$1"
+	t_begin "check body close messages" && {
+		< $r_out awk '
+/^path_info=\/'$pfx'\/[1-3]$/ { next }
+{ exit(2) }
+END { exit(NR == 3 ? 0 : 1) }
+'
+	}
+}
+
+req_keepalive () {
+	pfx="$1"
+	t_begin "make keepalive requests to trigger $pfx response body" && {
+		> $r_out
+		rm -f $curl_err $curl_out
+		curl -vsSf http://$listen/$pfx/[1-3] 2> $curl_err > $curl_out
+	}
+}
+
+req_keepalive file
+reload
+check_log file
+
+req_pipelined file
+reload
+check_log file
+
+req_keepalive blob
+reload
+check_log blob
+
+req_pipelined blob
+reload
+check_log blob
+
+req_keepalive pipe
+reload
+check_log pipe
+
+req_pipelined pipe
+reload
+check_log pipe
+
+t_begin "enable sendfile gem" && {
+	echo "require 'sendfile'" >> $unicorn_config
+	curl http://$listen/ >/dev/null # ensure worker is loaded before HUP
+}
+
+reload
+
+req_keepalive file
+reload
+check_log file
+
+req_pipelined file
+reload
+check_log file
+
+t_begin "killing succeeds" && {
+	kill $rainbows_pid
+}
+
+t_begin "check stderr" && {
+	check_stderr
+}
+
+t_done

data/t/t0102-rack-input-short.sh

@@ -8,21 +8,21 @@ t_begin "setup and startup" && {
 	rtmpfiles curl_out curl_err
 	rainbows_setup $model
 	rainbows -D sha1-random-size.ru -c $unicorn_config
-        blob_sha1=$(rsha1 < random_blob)
-        t_info "blob_sha1=$blob_sha1"
+	blob_sha1=$(rsha1 < random_blob)
+	t_info "blob_sha1=$blob_sha1"
 	rainbows_wait_start
 }
 
 t_begin "regular request" && {
 	curl -sSf -T random_blob http://$listen/ > $curl_out 2> $curl_err
-        test x$blob_sha1 = x$(cat $curl_out)
-        test ! -s $curl_err
+	test x$blob_sha1 = x$(cat $curl_out)
+	test ! -s $curl_err
 }
 
 t_begin "chunked request" && {
 	curl -sSf -T- < random_blob http://$listen/ > $curl_out 2> $curl_err
-        test x$blob_sha1 = x$(cat $curl_out)
-        test ! -s $curl_err
+	test x$blob_sha1 = x$(cat $curl_out)
+	test ! -s $curl_err
 }
 
 t_begin "shutdown" && {

data/t/t0106-rack-input-keepalive.sh

@@ -1,17 +1,63 @@
 #!/bin/sh
 . ./test-lib.sh
-t_plan 7 "rack.input pipelining test"
+t_plan 11 "rack.input pipelining test"
 
 t_begin "setup and startup" && {
 	rainbows_setup $model
-        rtmpfiles req
+	rtmpfiles req
 	rainbows -D sha1.ru -c $unicorn_config
 	body=hello
 	body_size=$(printf $body | wc -c)
 	body_sha1=$(printf $body | rsha1)
+	random_blob_size=$(wc -c < random_blob)
+	random_blob_sha1=$(rsha1 < random_blob)
 	rainbows_wait_start
 }
 
+t_begin "send big pipelined chunked requests" && {
+	(
+		cat $fifo > $tmp &
+		content-md5-put < random_blob
+		content-md5-put < random_blob
+		content-md5-put < random_blob
+		printf 'PUT / HTTP/1.0\r\n'
+		printf 'Content-Length: %d\r\n\r\n' $random_blob_size
+		cat random_blob
+		wait
+		echo ok > $ok
+	) | socat - TCP4:$listen > $fifo
+	test x"$(cat $ok)" = xok
+}
+
+t_begin "check responses" && {
+	dbgcat tmp
+	test 4 -eq $(grep $random_blob_sha1 $tmp | wc -l)
+}
+
+t_begin "send big pipelined identity requests" && {
+	(
+		cat $fifo > $tmp &
+		printf 'PUT / HTTP/1.0\r\n'
+		printf 'Connection: keep-alive\r\n'
+		printf 'Content-Length: %d\r\n\r\n' $random_blob_size
+		cat random_blob
+		printf 'PUT / HTTP/1.1\r\n'
+		printf 'Content-Length: %d\r\n\r\n' $random_blob_size
+		cat random_blob
+		printf 'PUT / HTTP/1.0\r\n'
+		printf 'Content-Length: %d\r\n\r\n' $random_blob_size
+		cat random_blob
+		wait
+		echo ok > $ok
+	) | socat - TCP4:$listen > $fifo
+	test x"$(cat $ok)" = xok
+}
+
+t_begin "check responses" && {
+	dbgcat tmp
+	test 3 -eq $(grep $random_blob_sha1 $tmp | wc -l)
+}
+
 t_begin "send pipelined identity requests" && {
 
 	{

data/t/t0113-rewindable-input-false.sh

@@ -0,0 +1,28 @@
+#!/bin/sh
+. ./test-lib.sh
+skip_models EventMachine NeverBlock
+skip_models Rev RevThreadSpawn RevThreadPool
+skip_models Coolio CoolioThreadSpawn CoolioThreadPool
+
+t_plan 4 "rewindable_input toggled to false"
+
+t_begin "setup and start" && {
+	rainbows_setup
+	echo rewindable_input false >> $unicorn_config
+	rainbows -D -c $unicorn_config t0113.ru
+	rainbows_wait_start
+}
+
+t_begin "ensure worker is started" && {
+	test xOK = x$(curl -T t0113.ru -H Expect: -vsSf http://$listen/)
+}
+
+t_begin "killing succeeds" && {
+	kill $rainbows_pid
+}
+
+t_begin "check stderr" && {
+	check_stderr
+}
+
+t_done

data/t/t0113.ru

@@ -0,0 +1,12 @@
+#\ -E none
+use Rack::ContentLength
+use Rack::ContentType, 'text/plain'
+app = lambda do |env|
+  case env['rack.input']
+  when Unicorn::StreamInput
+    [ 200, {}, %w(OK) ]
+  else
+    [ 500, {}, %w(NO) ]
+  end
+end
+run app

data/t/t0114-rewindable-input-true.sh

@@ -0,0 +1,28 @@
+#!/bin/sh
+. ./test-lib.sh
+skip_models EventMachine NeverBlock
+skip_models Rev RevThreadSpawn RevThreadPool
+skip_models Coolio CoolioThreadSpawn CoolioThreadPool
+
+t_plan 4 "rewindable_input toggled to true"
+
+t_begin "setup and start" && {
+	rainbows_setup
+	echo rewindable_input true >> $unicorn_config
+	rainbows -D -c $unicorn_config t0114.ru
+	rainbows_wait_start
+}
+
+t_begin "ensure worker is started" && {
+	test xOK = x$(curl -T t0114.ru -sSf http://$listen/)
+}
+
+t_begin "killing succeeds" && {
+	kill $rainbows_pid
+}
+
+t_begin "check stderr" && {
+	check_stderr
+}
+
+t_done

data/t/t0114.ru

@@ -0,0 +1,12 @@
+#\ -E none
+use Rack::ContentLength
+use Rack::ContentType, 'text/plain'
+app = lambda do |env|
+  case env['rack.input']
+  when Unicorn::TeeInput
+    [ 200, {}, %w(OK) ]
+  else
+    [ 500, {}, %w(NO) ]
+  end
+end
+run app

data/t/t9100-thread-timeout.sh

@@ -1,11 +1,13 @@
 #!/bin/sh
 . ./test-lib.sh
 case $model in
-ThreadSpawn|ThreadPool|RevThreadSpawn|RevThreadPool) ;;
+ThreadSpawn|ThreadPool) ;;
+RevThreadSpawn|RevThreadPool) ;;
+CoolioThreadSpawn|CoolioThreadPool) ;;
 *) t_info "$0 is only compatible with Thread*"; exit 0 ;;
 esac
 
-t_plan 5 "ThreadTimeout Rack middleware test for $model"
+t_plan 6 "ThreadTimeout Rack middleware test for $model"
 
 t_begin "configure and start" && {
 	rtmpfiles curl_err
@@ -25,6 +27,26 @@ t_begin "sleepy request times out with 408" && {
 	grep 408 $curl_err
 }
 
+t_begin "short requests do not timeout while making a long one" && {
+	rm -f $ok $curl_err
+	> $ok
+	curl -sSf http://$listen/2 2>$curl_err >/dev/null &
+	(
+		for i in $(awk </dev/null 'BEGIN{for(i=20;--i>=0;)print i}')
+		do
+			curl -sSf http://$listen/0.1 >> $ok 2>&1 &
+			test x"HI" = x"$(curl -sSf http://$listen/0.05)"
+		done
+		wait
+	)
+	test x"HI" = x"$(curl -sSf http://$listen/)"
+	wait
+	test -f $ok
+	test 20 -eq $(grep '^HI$' $ok | wc -l)
+	test x = x"$(grep -v '^HI$' $ok)"
+	grep 408 $curl_err
+}
+
 t_begin "kill server" && {
 	kill $rainbows_pid
 }

data/t/t9101-thread-timeout-threshold.sh

@@ -1,7 +1,9 @@
 #!/bin/sh
 . ./test-lib.sh
 case $model in
-ThreadSpawn|ThreadPool|RevThreadSpawn|RevThreadPool) ;;
+ThreadSpawn|ThreadPool) ;;
+RevThreadSpawn|RevThreadPool) ;;
+CoolioThreadSpawn|CoolioThreadPool) ;;
 *) t_info "$0 is only compatible with Thread*"; exit 0 ;;
 esac
 
@@ -30,25 +32,16 @@ t_begin "8 sleepy requests do not time out" && {
 	test xHI = x"$(sort < $curl_out | uniq)"
 }
 
-t_begin "9 sleepy requests do time out" && {
+t_begin "9 sleepy requests, some time out" && {
 	> $curl_err
 	> $curl_out
 	for i in 1 2 3 4 5 6 7 8 9
 	do
-		rtmpfiles curl_err_$i
 		curl -sSf --no-buffer \
-		  http://$listen/3 2>> ${curl_err}_${i} >> $curl_out &
+		  http://$listen/3 2>> $curl_err >> $curl_out &
 	done
 	wait
-	if test -s $curl_out
-	then
-		dbgcat curl_out
-		die "$curl_out should be empty"
-	fi
-	for i in 1 2 3 4 5 6 7 8 9
-	do
-		grep 408 ${curl_err}_${i}
-	done
+	grep 408 $curl_err
 }
 
 t_begin "kill server" && {

data/t/test-lib.sh

@@ -126,7 +126,7 @@ EOF
 		if test $# -ge 1
 		then
 			echo "  use :$1"
-			test $# -eq 2 && echo "  worker_connections $2"
+			test $# -ge 2 && echo "  worker_connections $2"
 			if test $# -eq 3
 			then
 				echo "  keepalive_timeout $3"
@@ -200,6 +200,7 @@ req_curl_chunked_upload_err_check () {
 
 case $model in
 Rev) require_check rev Rev::VERSION ;;
+Coolio) require_check coolio Coolio::VERSION ;;
 Revactor) require_check revactor Revactor::VERSION ;;
 EventMachine) require_check eventmachine EventMachine::VERSION ;;
 esac