unicorn-heroku 4.3.1.1.gc608.dirty

data/t/t0600-https-server-basic.sh

@@ -0,0 +1,48 @@
+#!/bin/sh
+. ./test-lib.sh
+t_plan 7 "simple HTTPS connection tests"
+
+t_begin "setup and start" && {
+	rtmpfiles curl_err
+	unicorn_setup
+cat > $unicorn_config <<EOF
+ssl do
+  listen "$listen"
+  ssl_certificate "server.crt"
+  ssl_certificate_key "server.key"
+end
+pid "$pid"
+stderr_path "$r_err"
+stdout_path "$r_out"
+EOF
+	unicorn -D -c $unicorn_config env.ru
+	unicorn_wait_start
+}
+
+t_begin "single request" && {
+	curl -sSfv --cacert ca.crt https://$listen/
+}
+
+t_begin "check stderr has no errors" && {
+	check_stderr
+}
+
+t_begin "multiple requests" && {
+	curl -sSfv --no-keepalive --cacert ca.crt \
+		https://$listen/ https://$listen/ 2>> $curl_err >> $tmp
+		dbgcat curl_err
+}
+
+t_begin "check stderr has no errors" && {
+	check_stderr
+}
+
+t_begin "killing succeeds" && {
+	kill $unicorn_pid
+}
+
+t_begin "check stderr has no errors" && {
+	check_stderr
+}
+
+t_done

data/t/t9000-preread-input.sh

@@ -0,0 +1,48 @@
+#!/bin/sh
+. ./test-lib.sh
+t_plan 9 "PrereadInput middleware tests"
+
+t_begin "setup and start" && {
+	random_blob_sha1=$(rsha1 < random_blob)
+	unicorn_setup
+	unicorn  -D -c $unicorn_config preread_input.ru
+	unicorn_wait_start
+}
+
+t_begin "single identity request" && {
+	curl -sSf -T random_blob http://$listen/ > $tmp
+}
+
+t_begin "sha1 matches" && {
+	test x"$(cat $tmp)" = x"$random_blob_sha1"
+}
+
+t_begin "single chunked request" && {
+	curl -sSf -T- < random_blob http://$listen/ > $tmp
+}
+
+t_begin "sha1 matches" && {
+	test x"$(cat $tmp)" = x"$random_blob_sha1"
+}
+
+t_begin "app only dispatched twice" && {
+	test 2 -eq "$(grep 'app dispatch:' < $r_err | wc -l )"
+}
+
+t_begin "aborted chunked request" && {
+	rm -f $tmp
+	curl -sSf -T- < $fifo http://$listen/ > $tmp &
+	curl_pid=$!
+	kill -9 $curl_pid
+	wait
+}
+
+t_begin "app only dispatched twice" && {
+	test 2 -eq "$(grep 'app dispatch:' < $r_err | wc -l )"
+}
+
+t_begin "killing succeeds" && {
+	kill -TERM $unicorn_pid
+}
+
+t_done

data/t/t9001-oob_gc.sh

@@ -0,0 +1,47 @@
+#!/bin/sh
+. ./test-lib.sh
+t_plan 9 "OobGC test"
+
+t_begin "setup and start" && {
+	unicorn_setup
+	unicorn -D -c $unicorn_config oob_gc.ru
+	unicorn_wait_start
+}
+
+t_begin "test default interval (4 requests)" && {
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+}
+
+t_begin "GC starting-request returns immediately" && {
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+}
+
+t_begin "GC is started after 5 requests" && {
+	test xtrue = x$(curl -vsSf http://$listen/ 2>> $tmp)
+}
+
+t_begin "reset GC" && {
+	test xfalse = x$(curl -vsSf -X POST http://$listen/gc_reset 2>> $tmp)
+}
+
+t_begin "test default interval again (3 requests)" && {
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+}
+
+t_begin "GC is started after 5 requests" && {
+	test xtrue = x$(curl -vsSf http://$listen/ 2>> $tmp)
+}
+
+t_begin "killing succeeds" && {
+	kill -TERM $unicorn_pid
+}
+
+t_begin "check_stderr" && check_stderr
+dbgcat r_err
+
+t_done

data/t/t9002-oob_gc-path.sh

@@ -0,0 +1,75 @@
+#!/bin/sh
+. ./test-lib.sh
+t_plan 12 "OobGC test with limited path"
+
+t_begin "setup and start" && {
+	unicorn_setup
+	unicorn -D -c $unicorn_config oob_gc_path.ru
+	unicorn_wait_start
+}
+
+t_begin "test default is noop" && {
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+}
+
+t_begin "4 bad requests to bump counter" && {
+	test xfalse = x$(curl -vsSf http://$listen/BAD 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/BAD 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/BAD 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/BAD 2>> $tmp)
+}
+
+t_begin "GC-starting request returns immediately" && {
+	test xfalse = x$(curl -vsSf http://$listen/BAD 2>> $tmp)
+}
+
+t_begin "GC was started after 5 requests" && {
+	test xtrue = x$(curl -vsSf http://$listen/ 2>> $tmp)
+}
+
+t_begin "reset GC" && {
+	test xfalse = x$(curl -vsSf -X POST http://$listen/gc_reset 2>> $tmp)
+}
+
+t_begin "test default is noop" && {
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/ 2>> $tmp)
+}
+
+t_begin "4 bad requests to bump counter" && {
+	test xfalse = x$(curl -vsSf http://$listen/BAD 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/BAD 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/BAD 2>> $tmp)
+	test xfalse = x$(curl -vsSf http://$listen/BAD 2>> $tmp)
+}
+
+t_begin "GC-starting request returns immediately" && {
+	test xfalse = x$(curl -vsSf http://$listen/BAD 2>> $tmp)
+}
+
+t_begin "GC was started after 5 requests" && {
+	test xtrue = x$(curl -vsSf http://$listen/ 2>> $tmp)
+}
+
+t_begin "killing succeeds" && {
+	kill -TERM $unicorn_pid
+}
+
+t_begin "check_stderr" && check_stderr
+
+t_done

data/t/test-lib.sh

@@ -0,0 +1,113 @@
+#!/bin/sh
+# Copyright (c) 2009 Rainbows! hackers
+# Copyright (c) 2010 Unicorn hackers
+. ./my-tap-lib.sh
+
+set +u
+
+# sometimes we rely on http_proxy to avoid wasting bandwidth with Isolate
+# and multiple Ruby versions
+NO_PROXY=${UNICORN_TEST_ADDR-127.0.0.1}
+export NO_PROXY
+
+set -e
+RUBY="${RUBY-ruby}"
+RUBY_VERSION=${RUBY_VERSION-$($RUBY -e 'puts RUBY_VERSION')}
+RUBY_ENGINE=${RUBY_ENGINE-$($RUBY -e 'puts((RUBY_ENGINE rescue "ruby"))')}
+t_pfx=$PWD/trash/$T-$RUBY_ENGINE-$RUBY_VERSION
+set -u
+
+PATH=$PWD/bin:$PATH
+export PATH
+
+test -x $PWD/bin/unused_listen || die "must be run in 't' directory"
+
+wait_for_pid () {
+	path="$1"
+	nr=30
+	while ! test -s "$path" && test $nr -gt 0
+	do
+		nr=$(($nr - 1))
+		sleep 1
+	done
+}
+
+# given a list of variable names, create temporary files and assign
+# the pathnames to those variables
+rtmpfiles () {
+	for id in "$@"
+	do
+		name=$id
+
+		case $name in
+		*fifo)
+			_tmp=$t_pfx.$id
+			eval "$id=$_tmp"
+			rm -f $_tmp
+			mkfifo $_tmp
+			T_RM_LIST="$T_RM_LIST $_tmp"
+			;;
+		*socket)
+			_tmp="$(mktemp -t $id.$$.XXXXXXXX)"
+			if test $(printf "$_tmp" |wc -c) -gt 108
+			then
+				echo >&2 "$_tmp too long, tests may fail"
+				echo >&2 "Try to set TMPDIR to a shorter path"
+			fi
+			eval "$id=$_tmp"
+			rm -f $_tmp
+			T_RM_LIST="$T_RM_LIST $_tmp"
+			;;
+		*)
+			_tmp=$t_pfx.$id
+			eval "$id=$_tmp"
+			> $_tmp
+			T_OK_RM_LIST="$T_OK_RM_LIST $_tmp"
+			;;
+		esac
+	done
+}
+
+dbgcat () {
+	id=$1
+	eval '_file=$'$id
+	echo "==> $id <=="
+	sed -e "s/^/$id:/" < $_file
+}
+
+check_stderr () {
+	set +u
+	_r_err=${1-${r_err}}
+	set -u
+	if grep -v $T $_r_err | grep -i Error
+	then
+		die "Errors found in $_r_err"
+	elif grep SIGKILL $_r_err
+	then
+		die "SIGKILL found in $_r_err"
+	fi
+}
+
+# unicorn_setup
+unicorn_setup () {
+	eval $(unused_listen)
+	port=$(expr $listen : '[^:]*:\([0-9]\+\)')
+	host=$(expr $listen : '\([^:]*\):[0-9]\+')
+
+	rtmpfiles unicorn_config pid r_err r_out fifo tmp ok
+	cat > $unicorn_config <<EOF
+listen "$listen"
+pid "$pid"
+stderr_path "$r_err"
+stdout_path "$r_out"
+EOF
+}
+
+unicorn_wait_start () {
+	# no need to play tricks with FIFOs since we got "ready_pipe" now
+	unicorn_pid=$(cat $pid)
+}
+
+rsha1 () {
+	sha1sum.rb
+}

data/t/test-rails3.sh

@@ -0,0 +1,27 @@
+. ./test-lib.sh
+RAILS_VERSION=${RAILS_VERSION-3.0.0}
+case $RUBY_VERSION in
+1.8.7|1.9.2) ;;
+*)
+	t_info "RUBY_VERSION=$RUBY_VERSION unsupported for Rails 3"
+	exit 0
+	;;
+esac
+
+arch_gems=../tmp/isolate/ruby-$RUBY_VERSION/gems
+rails_gems=../tmp/isolate/rails-$RAILS_VERSION/gems
+rails_bin="$rails_gems/rails-$RAILS_VERSION/bin/rails"
+if ! test -d "$arch_gems" || ! test -d "$rails_gems" || ! test -x "$rails_bin"
+then
+	( cd ../ && ./script/isolate_for_tests )
+fi
+
+for i in $arch_gems/*-* $rails_gems/*-*
+do
+	if test -d $i/lib
+	then
+		RUBYLIB=$(cd $i/lib && pwd):$RUBYLIB
+	fi
+done
+
+export RUBYLIB

data/t/write-on-close.ru

@@ -0,0 +1,11 @@
+class WriteOnClose
+  def each(&block)
+    @callback = block
+  end
+
+  def close
+    @callback.call "7\r\nGoodbye\r\n0\r\n\r\n"
+  end
+end
+use Rack::ContentType, "text/plain"
+run(lambda { |_| [ 200, [%w(Transfer-Encoding chunked)], WriteOnClose.new ] })

data/test/aggregate.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/ruby -n
+# -*- encoding: binary -*-
+
+BEGIN { $tests = $assertions = $failures = $errors = 0 }
+
+$_ =~ /(\d+) tests, (\d+) assertions, (\d+) failures, (\d+) errors/ or next
+$tests += $1.to_i
+$assertions += $2.to_i
+$failures += $3.to_i
+$errors += $4.to_i
+
+END {
+  printf("\n%d tests, %d assertions, %d failures, %d errors\n",
+         $tests, $assertions, $failures, $errors)
+}

data/test/benchmark/README

@@ -0,0 +1,50 @@
+= Performance
+
+Unicorn is pretty fast, and we want it to get faster.  Unicorn strives
+to get HTTP requests to your application and write HTTP responses back
+as quickly as possible.  Unicorn does not do any background processing
+while your app runs, so your app will get all the CPU time provided to
+it by your OS kernel.
+
+A gentle reminder: Unicorn is NOT for serving clients over slow network
+connections.  Use nginx (or something similar) to complement Unicorn if
+you have slow clients.
+
+== dd.ru
+
+This is a pure I/O benchmark.  In the context of Unicorn, this is the
+only one that matters.  It is a standard rackup-compatible .ru file and
+may be used with other Rack-compatible servers.
+
+  unicorn -E none dd.ru
+
+You can change the size and number of chunks in the response with
+the "bs" and "count" environment variables.   The following command
+will cause dd.ru to return 4 chunks of 16384 bytes each, leading to
+65536 byte response:
+
+  bs=16384 count=4 unicorn -E none dd.ru
+
+Or if you want to add logging (small performance impact):
+
+  unicorn -E deployment dd.ru
+
+Eric runs then runs clients on a LAN it in several different ways:
+
+  client@host1 -> unicorn@host1(tcp)
+  client@host2 -> unicorn@host1(tcp)
+  client@host3 -> nginx@host1 -> unicorn@host1(tcp)
+  client@host3 -> nginx@host1 -> unicorn@host1(unix)
+  client@host3 -> nginx@host2 -> unicorn@host1(tcp)
+
+The benchmark client is usually httperf.
+
+Another gentle reminder: performance with slow networks/clients
+is NOT our problem.  That is the job of nginx (or similar).
+
+== Contributors
+
+This directory is maintained independently in the "benchmark" branch
+based against v0.1.0.  Only changes to this directory (test/benchmarks)
+are committed to this branch although the master branch may merge this
+branch occassionaly.

data/test/benchmark/dd.ru

@@ -0,0 +1,18 @@
+# This benchmark is the simplest test of the I/O facilities in
+# unicorn.  It is meant to return a fixed-sized blob to test
+# the performance of things in Unicorn, _NOT_ the app.
+#
+# Adjusting this benchmark is done via the "bs" (byte size) and "count"
+# environment variables.  "count" designates the count of elements of
+# "bs" length in the Rack response body.  The defaults are bs=4096, count=1
+# to return one 4096-byte chunk.
+bs = ENV['bs'] ? ENV['bs'].to_i : 4096
+count = ENV['count'] ? ENV['count'].to_i : 1
+slice = (' ' * bs).freeze
+body = (1..count).map { slice }.freeze
+hdr = {
+  'Content-Length' => (bs * count).to_s.freeze,
+  'Content-Type' => 'text/plain'.freeze
+}.freeze
+response = [ 200, hdr, body ].freeze
+run(lambda { |env| response })