unicorn-lb-patch 4.3.1.11.g21b8.dirty

data/t/t0004-working_directory_broken.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+. ./test-lib.sh
+
+t_plan 3 "config.ru is missing inside alt working_directory"
+
+t_begin "setup" && {
+	unicorn_setup
+	rtmpfiles unicorn_config_tmp ok
+	rm -rf $t_pfx.app
+	mkdir $t_pfx.app
+
+	# the whole point of this exercise
+	echo "working_directory '$t_pfx.app'" >> $unicorn_config_tmp
+}
+
+t_begin "fails to start up w/o config.ru" && {
+	unicorn -c $unicorn_config_tmp || echo ok > $ok
+}
+
+t_begin "fallback code was run" && {
+	test x"$(cat $ok)" = xok
+}
+
+t_done

data/t/t0005-working_directory_app.rb.sh

@@ -0,0 +1,37 @@
+#!/bin/sh
+. ./test-lib.sh
+
+t_plan 4 "fooapp.rb inside alt working_directory"
+
+t_begin "setup and start" && {
+	unicorn_setup
+	rm -rf $t_pfx.app
+	mkdir $t_pfx.app
+
+	cat > $t_pfx.app/fooapp.rb <<\EOF
+class Fooapp
+  def self.call(env)
+    [ 200, [%w(Content-Type text/plain), %w(Content-Length 2)], %w(HI) ]
+  end
+end
+EOF
+	# the whole point of this exercise
+	echo "working_directory '$t_pfx.app'" >> $unicorn_config
+	cd /
+	unicorn -D -c $unicorn_config -I. fooapp.rb
+	unicorn_wait_start
+}
+
+t_begin "hit with curl" && {
+	body=$(curl -sSf http://$listen/)
+}
+
+t_begin "killing succeeds" && {
+	kill $unicorn_pid
+}
+
+t_begin "response body expected" && {
+	test x"$body" = xHI
+}
+
+t_done

data/t/t0006-reopen-logs.sh

@@ -0,0 +1,83 @@
+#!/bin/sh
+. ./test-lib.sh
+
+t_plan 15 "reopen rotated logs"
+
+t_begin "setup and startup" && {
+	rtmpfiles curl_out curl_err r_rot
+	unicorn_setup
+	unicorn -D t0006.ru -c $unicorn_config
+	unicorn_wait_start
+}
+
+t_begin "ensure server is responsive" && {
+	test xtrue = x$(curl -sSf http://$listen/ 2> $curl_err)
+}
+
+t_begin "ensure stderr log is clean" && check_stderr
+
+t_begin "external log rotation" && {
+	rm -f $r_rot
+	mv $r_err $r_rot
+}
+
+t_begin "send reopen log signal (USR1)" && {
+	kill -USR1 $unicorn_pid
+}
+
+t_begin "wait for rotated log to reappear" && {
+	nr=60
+	while ! test -f $r_err && test $nr -ge 0
+	do
+		sleep 1
+		nr=$(( $nr - 1 ))
+	done
+}
+
+t_begin "ensure server is still responsive" && {
+	test xtrue = x$(curl -sSf http://$listen/ 2> $curl_err)
+}
+
+t_begin "wait for worker to reopen logs" && {
+	nr=60
+	re="worker=.* done reopening logs"
+	while ! grep "$re" < $r_err >/dev/null && test $nr -ge 0
+	do
+		sleep 1
+		nr=$(( $nr - 1 ))
+	done
+}
+
+dbgcat r_rot
+dbgcat r_err
+
+t_begin "ensure no errors from curl" && {
+	test ! -s $curl_err
+}
+
+t_begin "current server stderr is clean" && check_stderr
+
+t_begin "rotated stderr is clean" && {
+	check_stderr $r_rot
+}
+
+t_begin "server is now writing logs to new stderr" && {
+	before_rot=$(wc -c < $r_rot)
+	before_err=$(wc -c < $r_err)
+	test xtrue = x$(curl -sSf http://$listen/ 2> $curl_err)
+	after_rot=$(wc -c < $r_rot)
+	after_err=$(wc -c < $r_err)
+	test $after_rot -eq $before_rot
+	test $after_err -gt $before_err
+}
+
+t_begin "stop server" && {
+	kill $unicorn_pid
+}
+
+dbgcat r_err
+
+t_begin "current server stderr is clean" && check_stderr
+t_begin "rotated stderr is clean" && check_stderr $r_rot
+
+t_done

data/t/t0006.ru

@@ -0,0 +1,13 @@
+use Rack::ContentLength
+use Rack::ContentType, "text/plain"
+run lambda { |env|
+
+  # our File objects for stderr/stdout should always have #path
+  # and be sync=true
+  ok = $stderr.sync &&
+       $stdout.sync &&
+       String === $stderr.path &&
+       String === $stdout.path
+
+  [ 200, {}, [ "#{ok}\n" ] ]
+}

data/t/t0007-working_directory_no_embed_cli.sh

@@ -0,0 +1,44 @@
+#!/bin/sh
+. ./test-lib.sh
+
+t_plan 4 "config.ru inside alt working_directory (no embedded switches)"
+
+t_begin "setup and start" && {
+	unicorn_setup
+	rm -rf $t_pfx.app
+	mkdir $t_pfx.app
+
+	cat > $t_pfx.app/config.ru <<EOF
+use Rack::ContentLength
+use Rack::ContentType, "text/plain"
+run lambda { |env| [ 200, {}, [ "#{\$master_ppid}\\n" ] ] }
+EOF
+	# the whole point of this exercise
+	echo "working_directory '$t_pfx.app'" >> $unicorn_config
+
+	# allows ppid to be 1 in before_fork
+	echo "preload_app true" >> $unicorn_config
+	cat >> $unicorn_config <<\EOF
+before_fork do |server,worker|
+  $master_ppid = Process.ppid # should be zero to detect daemonization
+end
+EOF
+
+	cd /
+	unicorn -D -c $unicorn_config
+	unicorn_wait_start
+}
+
+t_begin "hit with curl" && {
+	body=$(curl -sSf http://$listen/)
+}
+
+t_begin "killing succeeds" && {
+	kill $unicorn_pid
+}
+
+t_begin "response body ppid == 1 (daemonized)" && {
+	test "$body" -eq 1
+}
+
+t_done

data/t/t0008-back_out_of_upgrade.sh

@@ -0,0 +1,110 @@
+#!/bin/sh
+. ./test-lib.sh
+t_plan 13 "backout of USR2 upgrade"
+
+worker_wait_start () {
+	test xSTART = x"$(cat $fifo)"
+	unicorn_pid=$(cat $pid)
+}
+
+t_begin "setup and start" && {
+	unicorn_setup
+	rm -f $pid.oldbin
+
+cat >> $unicorn_config <<EOF
+after_fork do |server, worker|
+  # test script will block while reading from $fifo,
+  # so notify the script on the first worker we spawn
+  # by opening the FIFO
+  if worker.nr == 0
+    File.open("$fifo", "wb") { |fp| fp.syswrite "START" }
+  end
+end
+EOF
+	unicorn -D -c $unicorn_config pid.ru
+	worker_wait_start
+	orig_master_pid=$unicorn_pid
+}
+
+t_begin "read original worker pid" && {
+	orig_worker_pid=$(curl -sSf http://$listen/)
+	test -n "$orig_worker_pid" && kill -0 $orig_worker_pid
+}
+
+t_begin "upgrade to new master" && {
+	kill -USR2 $orig_master_pid
+}
+
+t_begin "kill old worker" && {
+	kill -WINCH $orig_master_pid
+}
+
+t_begin "wait for new worker to start" && {
+	worker_wait_start
+	test $unicorn_pid -ne $orig_master_pid
+	new_master_pid=$unicorn_pid
+}
+
+t_begin "old master pid is stashed in $pid.oldbin" && {
+	test -s "$pid.oldbin"
+	test $orig_master_pid -eq $(cat $pid.oldbin)
+}
+
+t_begin "ensure old worker is no longer running" && {
+	i=0
+	while kill -0 $orig_worker_pid 2>/dev/null
+	do
+		i=$(( $i + 1 ))
+		test $i -lt 600 || die "timed out"
+		sleep 1
+	done
+}
+
+t_begin "capture pid of new worker" && {
+	new_worker_pid=$(curl -sSf http://$listen/)
+}
+
+t_begin "reload old master process" && {
+	kill -HUP $orig_master_pid
+	worker_wait_start
+}
+
+t_begin "gracefully kill new master and ensure it dies" && {
+	kill -QUIT $new_master_pid
+	i=0
+	while kill -0 $new_worker_pid 2>/dev/null
+	do
+		i=$(( $i + 1 ))
+		test $i -lt 600 || die "timed out"
+		sleep 1
+	done
+}
+
+t_begin "ensure $pid.oldbin does not exist" && {
+	i=0
+	while test -s $pid.oldbin
+	do
+		i=$(( $i + 1 ))
+		test $i -lt 600 || die "timed out"
+		sleep 1
+	done
+	while ! test -s $pid
+	do
+		i=$(( $i + 1 ))
+		test $i -lt 600 || die "timed out"
+		sleep 1
+	done
+}
+
+t_begin "ensure $pid is correct" && {
+	cur_master_pid=$(cat $pid)
+	test $orig_master_pid -eq $cur_master_pid
+}
+
+t_begin "killing succeeds" && {
+	kill $orig_master_pid
+}
+
+dbgcat r_err
+
+t_done

data/t/t0009-broken-app.sh

@@ -0,0 +1,56 @@
+#!/bin/sh
+. ./test-lib.sh
+
+t_plan 9 "graceful handling of broken apps"
+
+t_begin "setup and start" && {
+	unicorn_setup
+	unicorn -E none -D broken-app.ru -c $unicorn_config
+	unicorn_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 broken-app.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 $unicorn_pid
+}
+
+t_begin "check stderr" && check_stderr
+
+t_done

data/t/t0009-winch_ttin.sh

@@ -0,0 +1,59 @@
+#!/bin/sh
+. ./test-lib.sh
+t_plan 8 "SIGTTIN succeeds after SIGWINCH"
+
+t_begin "setup and start" && {
+	unicorn_setup
+cat >> $unicorn_config <<EOF
+after_fork do |server, worker|
+  # test script will block while reading from $fifo,
+  File.open("$fifo", "wb") { |fp| fp.syswrite worker.nr.to_s }
+end
+EOF
+	unicorn -D -c $unicorn_config pid.ru
+	unicorn_wait_start
+	test 0 -eq $(cat $fifo) || die "worker.nr != 0"
+}
+
+t_begin "read worker pid" && {
+	orig_worker_pid=$(curl -sSf http://$listen/)
+	test -n "$orig_worker_pid" && kill -0 $orig_worker_pid
+}
+
+t_begin "stop all workers" && {
+	kill -WINCH $unicorn_pid
+}
+
+# we have to do this next step before delivering TTIN
+# signals aren't guaranteed to delivered in order
+t_begin "wait for worker to die" && {
+	i=0
+	while kill -0 $orig_worker_pid 2>/dev/null
+	do
+		i=$(( $i + 1 ))
+		test $i -lt 600 || die "timed out"
+		sleep 1
+	done
+}
+
+t_begin "start one worker back up" && {
+	kill -TTIN $unicorn_pid
+}
+
+t_begin "wait for new worker to start" && {
+	test 0 -eq $(cat $fifo) || die "worker.nr != 0"
+	new_worker_pid=$(curl -sSf http://$listen/)
+	test -n "$new_worker_pid" && kill -0 $new_worker_pid
+	test $orig_worker_pid -ne $new_worker_pid || \
+	   die "worker wasn't replaced"
+}
+
+t_begin "killing succeeds" && {
+	kill $unicorn_pid
+}
+
+t_begin "check stderr" && check_stderr
+
+dbgcat r_err
+
+t_done

data/t/t0010-reap-logging.sh

@@ -0,0 +1,55 @@
+#!/bin/sh
+. ./test-lib.sh
+t_plan 9 "reap worker logging messages"
+
+t_begin "setup and start" && {
+	unicorn_setup
+	cat >> $unicorn_config <<EOF
+after_fork { |s,w| File.open('$fifo','w') { |f| f.write '.' } }
+EOF
+	unicorn -c $unicorn_config pid.ru &
+	test '.' = $(cat $fifo)
+	unicorn_wait_start
+}
+
+t_begin "kill 1st worker=0" && {
+	pid_1=$(curl http://$listen/)
+	kill -9 $pid_1
+}
+
+t_begin "wait for 2nd worker to start" && {
+	test '.' = $(cat $fifo)
+}
+
+t_begin "ensure log of 1st reap is an ERROR" && {
+	dbgcat r_err
+	grep 'ERROR.*reaped.*worker=0' $r_err | grep $pid_1
+	dbgcat r_err
+	> $r_err
+}
+
+t_begin "kill 2nd worker gracefully" && {
+	pid_2=$(curl http://$listen/)
+	kill -QUIT $pid_2
+}
+
+t_begin "wait for 3rd worker=0 to start " && {
+	test '.' = $(cat $fifo)
+}
+
+t_begin "ensure log of 2nd reap is a INFO" && {
+	grep 'INFO.*reaped.*worker=0' $r_err | grep $pid_2
+	> $r_err
+}
+
+t_begin "killing succeeds" && {
+	kill $unicorn_pid
+	wait
+	kill -0 $unicorn_pid && false
+}
+
+t_begin "check stderr" && {
+	check_stderr
+}
+
+t_done