rainbows 0.3.0 → 0.4.0

data/t/bin/unused_listen

@@ -36,4 +36,4 @@ rescue Errno::EEXIST
   retry
 end
 sock.close rescue nil
-puts %Q(listen=#{addr}:#{port} _TEST_RM_LIST="$_TEST_RM_LIST #{lock_path}")
+puts %Q(listen=#{addr}:#{port} T_RM_LIST="$T_RM_LIST #{lock_path}")

data/t/large-file-response.ru

@@ -4,6 +4,7 @@ use Rack::ContentType
 map "/rss" do
   run lambda { |env|
     # on Linux, this is in kilobytes
+    GC.start if GC.respond_to?(:start)
     ::File.read("/proc/self/status") =~ /^VmRSS:\s+(\d+)/
     [ 200, {}, [ ($1.to_i * 1024).to_s ] ]
   }

data/t/my-tap-lib.sh

@@ -0,0 +1,200 @@
+#!/bin/sh
+# Copyright (c) 2009 Eric Wong <normalperson@yhbt.net>
+#
+# TAP-producing shell library for POSIX-compliant Bourne shells We do
+# not _rely_ on Bourne Again features, though we will use "set -o
+# pipefail" from ksh93 or bash 3 if available
+#
+# Only generic, non-project/non-language-specific stuff goes here.  We
+# only have POSIX dependencies for the core tests (without --verbose),
+# though we'll enable useful non-POSIX things if they're available.
+#
+# This test library is intentionally unforgiving, it does not support
+# skipping tests nor continuing after any failure.  Any failures
+# immediately halt execution as do any references to undefined
+# variables.
+#
+# When --verbose is specified, we always prefix stdout/stderr
+# output with "#" to avoid confusing TAP consumers.  Otherwise
+# the normal stdout/stderr streams are redirected to /dev/null
+
+# dup normal stdout(fd=1) and stderr (fd=2) to fd=3 and fd=4 respectively
+# normal TAP output goes to fd=3, nothing should go to fd=4
+exec 3>&1 4>&2
+
+# ensure a sane environment
+TZ=UTC LC_ALL=C LANG=C
+export LANG LC_ALL TZ
+unset CDPATH
+
+# pipefail is non-POSIX, but very useful in ksh93/bash
+( set -o pipefail 2>/dev/null ) && set -o pipefail
+
+SED=${SED-sed}
+
+# Unlike other test frameworks, we are unforgiving and bail immediately
+# on any failures.  We do this because we're lazy about error handling
+# and also because we believe anything broken should not be allowed to
+# propagate throughout the rest of the test
+set -e
+set -u
+
+# name of our test
+T=${0##*/}
+
+t_expect_nr=-1
+t_nr=0
+t_current=
+t_complete=false
+
+# list of files to remove unconditionally on exit
+T_RM_LIST=
+
+# list of files to remove only on successful exit
+T_OK_RM_LIST=
+
+# emit output to stdout, it'll be parsed by the TAP consumer
+# so it must be TAP-compliant output
+t_echo () {
+	echo >&3 "$@"
+}
+
+# emits non-parsed information to stdout, it will be prefixed with a '#'
+# to not throw off TAP consumers
+t_info () {
+	t_echo '#' "$@"
+}
+
+# exit with an error and print a diagnostic
+die () {
+	echo >&2 "$@"
+	exit 1
+}
+
+# our at_exit handler, it'll fire for all exits except SIGKILL (unavoidable)
+t_at_exit () {
+	code=$?
+	set +e
+	if test $code -eq 0
+	then
+		$t_complete || {
+			t_info "t_done not called"
+			code=1
+		}
+	elif test -n "$t_current"
+	then
+		t_echo "not ok $t_nr - $t_current"
+	fi
+	if test $t_expect_nr -ne -1
+	then
+		test $t_expect_nr -eq $t_nr || {
+			t_info "planned $t_expect_nr tests but ran $t_nr"
+			test $code -ne 0 || code=1
+		}
+	fi
+	$t_complete || {
+		t_info "unexpected test failure"
+		test $code -ne 0 || code=1
+	}
+	rm -f $T_RM_LIST
+	test $code -eq 0 && rm -f $T_OK_RM_LIST
+	set +x
+	exec >&3 2>&4
+	t_close_fds
+	exit $code
+}
+
+# close test-specific extra file descriptors
+t_close_fds () {
+	exec 3>&- 4>&-
+}
+
+# call this at the start of your test to specify the number of tests
+# you plan to run
+t_plan () {
+	test "$1" -ge 1 || die "must plan at least one test"
+	test $t_expect_nr -eq -1 || die "tried to plan twice in one test"
+	t_expect_nr=$1
+	shift
+	t_echo 1..$t_expect_nr "#" "$@"
+	trap t_at_exit EXIT
+}
+
+_t_checkup () {
+	test $t_expect_nr -le 0 && die "no tests planned"
+	test -n "$t_current" && t_echo "ok $t_nr - $t_current"
+	true
+}
+
+# finalizes any previously test and starts a new one
+t_begin () {
+	_t_checkup
+	t_nr=$(( $t_nr + 1 ))
+	t_current="$1"
+
+	# just in case somebody wanted to cheat us:
+	set -e
+}
+
+# finalizes the current test without starting a new one
+t_end () {
+	_t_checkup
+	t_current=
+}
+
+# run this to signify the end of your test
+t_done () {
+	_t_checkup
+	t_current=
+	t_complete=true
+	test $t_expect_nr -eq $t_nr || exit 1
+	exit 0
+}
+
+# create and assign named-pipes to variable _names_ passed to this function
+t_fifos () {
+	for _id in "$@"
+	do
+		_name=$_id
+		_tmp=$(mktemp -t $T.$$.$_id.XXXXXXXX)
+		eval "$_id=$_tmp"
+		rm -f $_tmp
+		mkfifo $_tmp
+		T_RM_LIST="$T_RM_LIST $_tmp"
+	done
+}
+
+t_verbose=false t_trace=false
+
+while test "$#" -ne 0
+do
+	arg="$1"
+	shift
+	case $arg in
+	-v|--verbose) t_verbose=true ;;
+	--trace) t_trace=true t_verbose=true ;;
+	*) die "Unknown option: $arg" ;;
+	esac
+done
+
+# we always only setup stdout, nothing should end up in the "real" stderr
+if $t_verbose
+then
+	if test x"$(which mktemp 2>/dev/null)" = x
+	then
+		die "mktemp(1) not available for --verbose"
+	fi
+	t_fifos t_stdout t_stderr
+
+	(
+		# use a subshell so seds are not waitable
+		$SED -e 's/^/#: /' $t_stdout &
+		$SED -e 's/^/#! /' $t_stderr &
+	) &
+	exec > $t_stdout 2> $t_stderr
+else
+	exec > /dev/null 2> /dev/null
+fi
+
+$t_trace && set -x
+true

data/t/simple-http_Base.ru

@@ -0,0 +1,3 @@
+use Rack::ContentLength
+use Rack::ContentType
+run lambda { |env| [ 200, {}, [ env.inspect << "\n" ] ] }

data/t/simple-http_EventMachine.ru

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

data/t/simple-http_Rev.ru

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

data/t/simple-http_Revactor.ru

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

data/t/simple-http_ThreadPool.ru

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

data/t/simple-http_ThreadSpawn.ru

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

data/t/t0000-simple-http.sh

@@ -0,0 +1,142 @@
+#!/bin/sh
+. ./test-lib.sh
+t_plan 24 "simple HTTP connection keepalive/pipelining tests for $model"
+
+t_begin "checking for config.ru for $model" && {
+	tbase=simple-http_$model.ru
+	test -f "$tbase"
+}
+
+t_begin "setup and start" && {
+	rainbows_setup
+	rainbows -D $tbase -c $unicorn_config
+	rainbows_wait_start
+}
+
+t_begin "pid file exists" && {
+	test -f $pid
+}
+
+t_begin "single request" && {
+	curl -sSfv http://$listen/
+}
+
+dbgcat r_err
+
+t_begin "two requests with keepalive" && {
+	curl -sSfv http://$listen/a http://$listen/b > $tmp 2>&1
+}
+
+dbgcat r_err
+dbgcat tmp
+
+t_begin "reused existing connection" && {
+	grep 'Re-using existing connection' < $tmp
+}
+
+t_begin "pipelining partial requests" && {
+	req='GET / HTTP/1.1\r\nHost: example.com\r\n'
+	(
+		cat $fifo > $tmp &
+		printf "$req"'\r\n'"$req"
+		sleep 1
+		printf 'Connection: close\r\n\r\n'
+		wait
+		echo ok > $ok
+	) | socat - TCP:$listen > $fifo
+}
+dbgcat tmp
+
+t_begin "two HTTP/1.1 responses" && {
+	test 2 -eq $(grep '^HTTP/1.1' $tmp | wc -l)
+}
+
+t_begin "two HTTP/1.1 200 OK responses" && {
+	test 2 -eq $(grep '^HTTP/1.1 200 OK' $tmp | wc -l)
+}
+
+t_begin 'one "Connection: keep-alive" response' && {
+	test 1 -eq $(grep '^Connection: keep-alive' $tmp | wc -l)
+}
+
+t_begin 'one "Connection: close" response' && {
+	test 1 -eq $(grep '^Connection: close' $tmp | wc -l)
+}
+
+t_begin 'check subshell success' && {
+	test x"$(cat $ok)" = xok
+}
+
+
+t_begin "check stderr" && {
+	check_stderr
+}
+
+t_begin "burst pipelining requests" && {
+	req='GET / HTTP/1.1\r\nHost: example.com\r\n'
+	(
+		cat $fifo > $tmp &
+		printf "$req"'\r\n'"$req"'Connection: close\r\n\r\n'
+		wait
+		echo ok > $ok
+	) | socat - TCP:$listen > $fifo
+}
+
+dbgcat tmp
+dbgcat r_err
+
+t_begin "got 2 HTTP/1.1 responses from pipelining" && {
+	test 2 -eq $(grep '^HTTP/1.1' $tmp | wc -l)
+}
+
+t_begin "got 2 HTTP/1.1 200 OK responses" && {
+	test 2 -eq $(grep '^HTTP/1.1 200 OK' $tmp | wc -l)
+}
+
+t_begin "one keepalive connection" && {
+	test 1 -eq $(grep '^Connection: keep-alive' $tmp | wc -l)
+}
+
+t_begin "second request closes connection" && {
+	test 1 -eq $(grep '^Connection: close' $tmp | wc -l)
+}
+
+t_begin "subshell exited correctly" && {
+	test x"$(cat $ok)" = xok
+}
+
+t_begin "stderr log has no errors" && {
+	check_stderr
+}
+
+t_begin "HTTP/0.9 request should not return headers" && {
+	(
+		printf 'GET /\r\n'
+		cat $fifo > $tmp &
+		wait
+		echo ok > $ok
+	) | socat - TCP:$listen > $fifo
+}
+
+dbgcat tmp
+dbgcat r_err
+
+t_begin "env.inspect should've put everything on one line" && {
+	test 1 -eq $(wc -l < $tmp)
+}
+
+t_begin "no headers in output" && {
+	if grep ^Connection: $tmp
+	then
+		die "Connection header found in $tmp"
+	elif grep ^HTTP/ $tmp
+	then
+		die "HTTP/ found in $tmp"
+	fi
+}
+
+t_begin "killing succeeds" && {
+	kill $rainbows_pid
+}
+
+t_done

data/t/t0001-unix-http.sh

@@ -0,0 +1,103 @@
+#!/bin/sh
+. ./test-lib.sh
+t_plan 18 "simple HTTP connection keepalive/pipelining tests for $model"
+
+t_begin "checking for config.ru for $model" && {
+	tbase=simple-http_$model.ru
+	test -f "$tbase"
+}
+
+t_begin "setup and start" && {
+	rtmpfiles unix_socket
+	rainbows_setup
+	echo "listen '$unix_socket'" >> $unicorn_config
+	rainbows -D $tbase -c $unicorn_config
+	rainbows_wait_start
+}
+
+t_begin "pid file exists" && {
+	test -f $pid
+}
+
+t_begin "single TCP request" && {
+	curl -sSfv http://$listen/
+}
+
+dbgcat r_err
+
+t_begin "pipelining partial requests" && {
+	req='GET / HTTP/1.1\r\nHost: example.com\r\n'
+	(
+		cat $fifo > $tmp &
+		printf "$req"'\r\n'"$req"
+		sleep 1
+		printf 'Connection: close\r\n\r\n'
+		wait
+		echo ok > $ok
+	) | socat - UNIX:$unix_socket > $fifo
+}
+dbgcat tmp
+
+t_begin "two HTTP/1.1 responses" && {
+	test 2 -eq $(grep '^HTTP/1.1' $tmp | wc -l)
+}
+
+t_begin "two HTTP/1.1 200 OK responses" && {
+	test 2 -eq $(grep '^HTTP/1.1 200 OK' $tmp | wc -l)
+}
+
+t_begin 'one "Connection: keep-alive" response' && {
+	test 1 -eq $(grep '^Connection: keep-alive' $tmp | wc -l)
+}
+
+t_begin 'one "Connection: close" response' && {
+	test 1 -eq $(grep '^Connection: close' $tmp | wc -l)
+}
+
+t_begin 'check subshell success' && {
+	test x"$(cat $ok)" = xok
+}
+
+
+t_begin "check stderr" && {
+	check_stderr
+}
+
+t_begin "burst pipelining requests" && {
+	req='GET / HTTP/1.1\r\nHost: example.com\r\n'
+	(
+		cat $fifo > $tmp &
+		printf "$req"'\r\n'"$req"'Connection: close\r\n\r\n'
+		wait
+		echo ok > $ok
+	) | socat - UNIX:$unix_socket > $fifo
+}
+
+dbgcat tmp
+dbgcat r_err
+
+t_begin "two HTTP/1.1 responses" && {
+	test 2 -eq $(grep '^HTTP/1.1' $tmp | wc -l)
+}
+
+t_begin "two HTTP/1.1 200 OK responses" && {
+	test 2 -eq $(grep '^HTTP/1.1 200 OK' $tmp | wc -l)
+}
+
+t_begin 'one "Connection: keep-alive" response' && {
+	test 1 -eq $(grep '^Connection: keep-alive' $tmp | wc -l)
+}
+
+t_begin 'one "Connection: close" response' && {
+	test 1 -eq $(grep '^Connection: close' $tmp | wc -l)
+}
+
+t_begin 'check subshell success' && {
+	test x"$(cat $ok)" = xok
+}
+
+t_begin "killing succeeds" && {
+	kill $rainbows_pid
+}
+
+t_done