rainbows 0.95.1 → 0.96.0

data/t/GNUmakefile

@@ -27,7 +27,6 @@ models += Rev
 models += EventMachine
 models += NeverBlock
 models += RevThreadSpawn
-models += RevThreadPool
 
 ifeq ($(RUBY_ENGINE),ruby)
   rp := )
@@ -37,6 +36,7 @@ ifeq ($(RUBY_ENGINE),ruby)
     models += FiberSpawn
     models += RevFiberSpawn
     models += FiberPool
+    models += RevThreadPool
   endif
 endif
 
@@ -118,7 +118,7 @@ $(MODEL_T): script = $(subst $(model).,,$@)
 $(MODEL_T): export RUBY := $(RUBY)
 $(MODEL_T): export PATH := $(bindir):$(PATH)
 $(MODEL_T): $(t_deps)
-	RUBYLIB=$(rainbows_lib):$$(cat $(libs)) \
+	RUBYLIB=$(rainbows_lib):$$(cat $(libs)):$(RUBYLIB) \
 	   $(TRACER) $(SHELL) $(SH_TEST_OPTS) $(script) $(TEST_OPTS)
 
 trash/.gitignore:

data/t/close-pipe-response.ru

@@ -0,0 +1,25 @@
+# must be run without Rack::Lint since that clobbers to_path
+class CloseWrapper < Struct.new(:to_io)
+  def each(&block)
+    to_io.each(&block)
+  end
+
+  def close
+    ::File.open(ENV['fifo'], 'wb') do |fp|
+      fp.syswrite("CLOSING #{to_io}\n")
+      if to_io.respond_to?(:close) && ! to_io.closed?
+        to_io.close
+      end
+    end
+  end
+end
+use Rainbows::DevFdResponse
+run(lambda { |env|
+  io = IO.popen('cat random_blob', 'rb')
+  [ 200,
+    {
+      'Content-Length' => ::File.stat('random_blob').size.to_s,
+      'Content-Type' => 'application/octet-stream',
+    },
+    CloseWrapper[io] ]
+})

data/t/cramp/rainsocket.ru

@@ -19,7 +19,7 @@ class WelcomeController < Cramp::Controller::Websocket
   end
 
   def send_hello_world
-    render "Hello from the Server!\n"
+    render("Hello from the Server!\n" * 256)
   end
 end
 

data/t/fast-pipe-response.ru

@@ -0,0 +1,10 @@
+# must be run without Rack::Lint since that clobbers to_path
+use Rainbows::DevFdResponse
+run(lambda { |env|
+  [ 200,
+    {
+      'Content-Length' => ::File.stat('random_blob').size.to_s,
+      'Content-Type' => 'application/octet-stream',
+    },
+    IO.popen('cat random_blob', 'rb') ]
+})

data/t/file-wrap-to_path.ru

@@ -0,0 +1,24 @@
+# must be run without Rack::Lint since that clobbers to_path
+class Wrapper < Struct.new(:app)
+  def call(env)
+    status, headers, body = app.call(env)
+    body = Body.new(body) if body.respond_to?(:to_path)
+    [ status, headers, body ]
+  end
+
+  class Body < Struct.new(:body)
+    def to_path
+      body.to_path
+    end
+
+    def each(&block)
+      body.each(&block)
+    end
+
+    def close
+      ::File.open(ENV['fifo'], 'wb') { |fp| fp.puts "CLOSING" }
+    end
+  end
+end
+use Wrapper
+run Rack::File.new(Dir.pwd)

data/t/t0015-working_directory.sh

@@ -6,7 +6,7 @@ then
 fi
 . ./test-lib.sh
 
-t_plan 4 "config.ru inside alt working_directory"
+t_plan 5 "config.ru inside alt working_directory"
 
 t_begin "setup and start" && {
 	rainbows_setup
@@ -53,4 +53,8 @@ t_begin "response body ppid == 1 (daemonized)" && {
 	test "$body" -eq 1
 }
 
+t_begin "cleanup working directory" && {
+	rm -r $t_pfx.app
+}
+
 t_done

data/t/t0020-large-sendfile-response.sh

@@ -46,7 +46,7 @@ t_begin "send a batch of abortive HTTP/1.1 requests in parallel" && {
 	do
 		rm -f $i
 		(
-			curl -sSf --max-time 5 --limit-rate 1K \
+			curl -sSf --max-time 2 --limit-rate 1K \
 			  http://$listen/random_blob >/dev/null || echo ok > $i
 		) &
 	done
@@ -77,11 +77,11 @@ t_begin "check proc to ensure file is closed properly (Linux only)" && {
 
 t_begin "send a bunch of HTTP/1.1 requests in parallel" && {
 	(
-		curl -sSf --limit-rate 1M http://$listen/random_blob | \
+		curl -sSf --limit-rate 5M http://$listen/random_blob | \
 		  rsha1 > $slow_a
 	) &
 	(
-		curl -sSf --limit-rate 750K http://$listen/random_blob | \
+		curl -sSf --limit-rate 6M http://$listen/random_blob | \
 		  rsha1 > $slow_b
 	) &
 	for i in $a $b $c

data/t/t0021-sendfile-wrap-to_path.sh

@@ -0,0 +1,108 @@
+#!/bin/sh
+. ./test-lib.sh
+test -r random_blob || die "random_blob required, run with 'make $0'"
+case $RUBY_ENGINE in
+ruby) ;;
+*)
+	t_info "skipping $T since it can't load the sendfile gem, yet"
+	exit 0
+	;;
+esac
+
+t_plan 16 "sendfile wrap body response for $model"
+
+t_begin "setup and startup" && {
+	rtmpfiles out err http_fifo sub_ok
+	rainbows_setup $model
+	echo 'require "sendfile"' >> $unicorn_config
+	echo 'def (::IO).copy_stream(*x); abort "NO"; end' >> $unicorn_config
+
+	# can't load Rack::Lint here since it clobbers body#to_path
+	export fifo
+	rainbows -E none -D file-wrap-to_path.ru -c $unicorn_config
+	rainbows_wait_start
+}
+
+t_begin "read random blob sha1" && {
+	random_blob_sha1=$(rsha1 < random_blob)
+}
+
+t_begin "start FIFO reader" && {
+	cat $fifo > $out &
+}
+
+t_begin "single request matches" && {
+	sha1=$(curl -sSfv 2> $err http://$listen/random_blob | rsha1)
+	test -n "$sha1"
+	test x"$sha1" = x"$random_blob_sha1"
+}
+
+t_begin "body.close called" && {
+	wait # for cat $fifo
+	grep CLOSING $out || die "body.close not logged"
+}
+
+t_begin "start FIFO reader for abortive HTTP/1.1 request" && {
+	cat $fifo > $out &
+}
+
+t_begin "send abortive HTTP/1.1 request" && {
+	rm -f $ok
+	(
+		printf 'GET /random_blob HTTP/1.1\r\nHost: example.com\r\n\r\n'
+		dd bs=4096 count=1 < $http_fifo >/dev/null
+		echo ok > $ok
+	) | socat - TCP:$listen > $http_fifo || :
+	test xok = x$(cat $ok)
+}
+
+t_begin "body.close called for aborted HTTP/1.1 request" && {
+	wait # for cat $fifo
+	grep CLOSING $out || die "body.close not logged"
+}
+
+t_begin "start FIFO reader for abortive HTTP/1.0 request" && {
+	cat $fifo > $out &
+}
+
+t_begin "send abortive HTTP/1.0 request" && {
+	rm -f $ok
+	(
+		printf 'GET /random_blob HTTP/1.0\r\n\r\n'
+		dd bs=4096 count=1 < $http_fifo >/dev/null
+		echo ok > $ok
+	) | socat - TCP:$listen > $http_fifo || :
+	test xok = x$(cat $ok)
+}
+
+t_begin "body.close called for aborted HTTP/1.0 request" && {
+	wait # for cat $fifo
+	grep CLOSING $out || die "body.close not logged"
+}
+
+t_begin "start FIFO reader for abortive HTTP/0.9 request" && {
+	cat $fifo > $out &
+}
+
+t_begin "send abortive HTTP/0.9 request" && {
+	rm -f $ok
+	(
+		printf 'GET /random_blob\r\n'
+		dd bs=4096 count=1 < $http_fifo >/dev/null
+		echo ok > $ok
+	) | socat - TCP:$listen > $http_fifo || :
+	test xok = x$(cat $ok)
+}
+
+t_begin "body.close called for aborted HTTP/0.9 request" && {
+	wait # for cat $fifo
+	grep CLOSING $out || die "body.close not logged"
+}
+
+t_begin "shutdown server" && {
+	kill -QUIT $rainbows_pid
+}
+
+t_begin "check stderr" && check_stderr
+
+t_done

data/t/t0022-copy_stream-byte-range.sh

@@ -0,0 +1,139 @@
+#!/bin/sh
+. ./test-lib.sh
+test -r random_blob || die "random_blob required, run with 'make $0'"
+case $RUBY_VERSION in
+1.9.*) ;;
+*)
+	t_info "skipping $T since it can't IO.copy_stream"
+	exit 0
+	;;
+esac
+
+case $model in
+ThreadSpawn|WriterThreadSpawn|ThreadPool|WriterThreadPool|Base) ;;
+*)
+	t_info "skipping $T since it doesn't use IO.copy_stream"
+	exit 0
+	;;
+esac
+
+t_plan 11 "IO.copy_stream byte range response for $model"
+
+t_begin "setup and startup" && {
+	rtmpfiles out err
+	rainbows_setup $model
+	# can't load Rack::Lint here since it clobbers body#to_path
+	rainbows -E none -D large-file-response.ru -c $unicorn_config
+	rainbows_wait_start
+	random_blob_size=$(wc -c < random_blob)
+	rb_1=$(( $random_blob_size - 1 ))
+	range_head=-r-365
+	range_tail=-r155-
+	range_mid=-r200-300
+	range_n1=-r0-$rb_1
+	range_n2=-r0-$(($rb_1 - 1))
+	range_1b_head=-r0-0
+	range_1b_tail=-r$rb_1-$rb_1
+	range_1b_mid=-r200-200
+	range_all=-r0-$random_blob_size
+	url=http://$listen/random_blob
+}
+
+check_content_range () {
+	# Content-Range: bytes #{offset}-#{offset+count-1}/#{clen}
+	awk -F/ -v E=0 -v size=$random_blob_size '
+	$2 == size && /^< Content-Range: bytes [0-9]+-[0-9]+\// {
+		split($1, a, /-/);
+		if (a[1] < size) {
+			E = 0;
+			exit(0);
+		}
+	}
+	END { exit(E) }
+	' < $err
+}
+
+t_begin "read random blob sha1s" && {
+	sha1_head=$(curl -sSff $range_head file://random_blob | rsha1)
+	sha1_tail=$(curl -sSff $range_tail file://random_blob | rsha1)
+	sha1_mid=$(curl -sSff $range_mid file://random_blob | rsha1)
+	sha1_n1=$(curl -sSff $range_n1 file://random_blob | rsha1)
+	sha1_n2=$(curl -sSff $range_n2 file://random_blob | rsha1)
+	sha1_1b_head=$(curl -sSff $range_1b_head file://random_blob | rsha1)
+	sha1_1b_tail=$(curl -sSff $range_1b_tail file://random_blob | rsha1)
+	sha1_1b_mid=$(curl -sSff $range_1b_mid file://random_blob | rsha1)
+	sha1_all=$(rsha1 < random_blob)
+	echo "$sha1_all=$sha1_n1"
+}
+
+t_begin "normal full request matches" && {
+	sha1="$(curl -v 2>$err -sSf $url | rsha1)"
+	test x"$sha1_all" = x"$sha1"
+	grep 'Content-Range:' $err && die "Content-Range unexpected"
+	grep 'HTTP/1.1 200 OK' $err || die "200 response expected"
+}
+
+t_begin "crazy offset goes over" && {
+	range_insane=-r$(($random_blob_size * 2))-$(($random_blob_size * 4))
+	curl -vsS 2>$err $range_insane $url
+	grep 'HTTP/1\.[01] 416 ' $err || die "expected 416 error"
+}
+
+t_begin "full request matches with explicit ranges" && {
+	sha1="$(curl -v 2>$err $range_all -sSf $url | rsha1)"
+	check_content_range
+	test x"$sha1_all" = x"$sha1"
+
+	sha1="$(curl -v 2>$err $range_n1 -sSf $url | rsha1)"
+	check_content_range
+	test x"$sha1_all" = x"$sha1"
+
+	range_over=-r0-$(($random_blob_size * 2))
+	sha1="$(curl -v 2>$err $range_over -sSf $url | rsha1)"
+	check_content_range
+	test x"$sha1_all" = x"$sha1"
+}
+
+t_begin "no fence post errors" && {
+	sha1="$(curl -v 2>$err $range_n2 -sSf $url | rsha1)"
+	check_content_range
+	test x"$sha1_n2" = x"$sha1"
+
+	sha1="$(curl -v 2>$err $range_1b_head -sSf $url | rsha1)"
+	check_content_range
+	test x"$sha1_1b_head" = x"$sha1"
+
+	sha1="$(curl -v 2>$err $range_1b_tail -sSf $url | rsha1)"
+	check_content_range
+	test x"$sha1_1b_tail" = x"$sha1"
+
+	sha1="$(curl -v 2>$err $range_1b_mid -sSf $url | rsha1)"
+	check_content_range
+	test x"$sha1_1b_mid" = x"$sha1"
+}
+
+t_begin "head range matches" && {
+	sha1="$(curl -sSfv $range_head $url | rsha1)"
+	check_content_range
+	test x"$sha1_head" = x"$sha1"
+}
+
+t_begin "tail range matches" && {
+	sha1="$(curl -sSf $range_tail $url | rsha1)"
+	check_content_range
+	test x"$sha1_tail" = x"$sha1"
+}
+
+t_begin "mid range matches" && {
+	sha1="$(curl -sSf $range_mid $url | rsha1)"
+	check_content_range
+	test x"$sha1_mid" = x"$sha1"
+}
+
+t_begin "shutdown server" && {
+	kill -QUIT $rainbows_pid
+}
+
+t_begin "check stderr" && check_stderr
+
+t_done

data/t/t0023-sendfile-byte-range.sh

@@ -0,0 +1,63 @@
+#!/bin/sh
+. ./test-lib.sh
+test -r random_blob || die "random_blob required, run with 'make $0'"
+case $RUBY_ENGINE in
+ruby) ;;
+*)
+	t_info "skipping $T since it can't load the sendfile gem, yet"
+	exit 0
+	;;
+esac
+
+case $model in
+EventMachine|NeverBlock)
+	t_info "skipping $T since it's not compatible with $model"
+	exit 0
+	;;
+*) ;;
+esac
+
+t_plan 7 "sendfile byte range response for $model"
+
+t_begin "setup and startup" && {
+	rtmpfiles out err
+	rainbows_setup $model
+	echo 'require "sendfile"' >> $unicorn_config
+	echo 'def (::IO).copy_stream(*x); abort "NO"; end' >> $unicorn_config
+
+	# can't load Rack::Lint here since it clobbers body#to_path
+	rainbows -E none -D large-file-response.ru -c $unicorn_config
+	rainbows_wait_start
+	range_head=-r-365
+	range_tail=-r155-
+	range_mid=-r200-300
+}
+
+t_begin "read random blob sha1s" && {
+	sha1_head=$(curl -sSf $range_head file://random_blob | rsha1)
+	sha1_tail=$(curl -sSf $range_tail file://random_blob | rsha1)
+	sha1_mid=$(curl -sSf $range_mid file://random_blob | rsha1)
+}
+
+t_begin "head range matches" && {
+	sha1="$(curl -sSv $range_head http://$listen/random_blob | rsha1)"
+	test x"$sha1_head" = x"$sha1"
+}
+
+t_begin "tail range matches" && {
+	sha1="$(curl -sS $range_tail http://$listen/random_blob | rsha1)"
+	test x"$sha1_tail" = x"$sha1"
+}
+
+t_begin "mid range matches" && {
+	sha1="$(curl -sS $range_mid http://$listen/random_blob | rsha1)"
+	test x"$sha1_mid" = x"$sha1"
+}
+
+t_begin "shutdown server" && {
+	kill -QUIT $rainbows_pid
+}
+
+t_begin "check stderr" && check_stderr
+
+t_done