unicorn-maintained 6.2.0

data/t/my-tap-lib.sh

@@ -0,0 +1,201 @@
+#!/bin/sh
+# Copyright (c) 2009, 2010 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 &
+	) &
+	wait
+	exec > $t_stdout 2> $t_stderr
+else
+	exec > /dev/null 2> /dev/null
+fi
+
+$t_trace && set -x
+true

data/t/oob_gc.ru

@@ -0,0 +1,17 @@
+#\-E none
+require 'unicorn/oob_gc'
+use Rack::ContentLength
+use Rack::ContentType, "text/plain"
+use Unicorn::OobGC
+$gc_started = false
+
+# Mock GC.start
+def GC.start
+  $gc_started = true
+end
+run lambda { |env|
+  if "/gc_reset" == env["PATH_INFO"] && "POST" == env["REQUEST_METHOD"]
+    $gc_started = false
+  end
+  [ 200, {}, [ "#$gc_started\n" ] ]
+}

data/t/oob_gc_path.ru

@@ -0,0 +1,17 @@
+#\-E none
+require 'unicorn/oob_gc'
+use Rack::ContentLength
+use Rack::ContentType, "text/plain"
+use Unicorn::OobGC, 5, /BAD/
+$gc_started = false
+
+# Mock GC.start
+def GC.start
+  $gc_started = true
+end
+run lambda { |env|
+  if "/gc_reset" == env["PATH_INFO"] && "POST" == env["REQUEST_METHOD"]
+    $gc_started = false
+  end
+  [ 200, {}, [ "#$gc_started\n" ] ]
+}

data/t/pid.ru

@@ -0,0 +1,3 @@
+use Rack::ContentLength
+use Rack::ContentType, "text/plain"
+run lambda { |env| [ 200, {}, [ "#$$\n" ] ] }

data/t/preread_input.ru

@@ -0,0 +1,22 @@
+#\-E none
+require 'digest/md5'
+require 'unicorn/preread_input'
+use Unicorn::PrereadInput
+nr = 0
+run lambda { |env|
+  $stderr.write "app dispatch: #{nr += 1}\n"
+  input = env["rack.input"]
+  dig = Digest::MD5.new
+  if buf = input.read(16384)
+    begin
+      dig.update(buf)
+    end while input.read(16384, buf)
+    buf.clear # remove this call if Ruby ever gets escape analysis
+  end
+  if env['HTTP_TRAILER'] =~ /\bContent-MD5\b/i
+    cmd5_b64 = env['HTTP_CONTENT_MD5'] or return [500, {}, ['No Content-MD5']]
+    cmd5_bin = cmd5_b64.unpack('m')[0]
+    return [500, {}, [ cmd5_b64 ] ] if cmd5_bin != dig.digest
+  end
+  [ 200, {}, [ dig.hexdigest ] ]
+}

data/t/reload-bad-config.t

@@ -0,0 +1,54 @@
+#!perl -w
+# Copyright (C) unicorn hackers <unicorn-public@yhbt.net>
+# License: GPL-3.0+ <https://www.gnu.org/licenses/gpl-3.0.txt>
+use v5.14; BEGIN { require './t/lib.perl' };
+use autodie;
+my $srv = tcp_server();
+my $host_port = tcp_host_port($srv);
+my $ru = "$tmpdir/config.ru";
+my $u_conf = "$tmpdir/u.conf.rb";
+
+open my $fh, '>', $ru;
+print $fh <<'EOM';
+use Rack::ContentLength
+use Rack::ContentType, 'text/plain'
+config = ru = "hello world\n" # check for config variable conflicts, too
+run lambda { |env| [ 200, {}, [ ru.to_s ] ] }
+EOM
+close $fh;
+
+open $fh, '>', $u_conf;
+print $fh <<EOM;
+preload_app true
+stderr_path "$err_log"
+EOM
+close $fh;
+
+my $ar = unicorn(qw(-E none -c), $u_conf, $ru, { 3 => $srv });
+my ($status, $hdr, $bdy) = do_req($srv, 'GET / HTTP/1.0');
+like($status, qr!\AHTTP/1\.[01] 200\b!, 'status line valid at start');
+is($bdy, "hello world\n", 'body matches expected');
+
+open $fh, '>>', $ru;
+say $fh '....this better be a syntax error in any version of ruby...';
+close $fh;
+
+$ar->do_kill('HUP'); # reload
+my @l;
+for (1..1000) {
+	@l = grep(/(?:done|error) reloading/, slurp($err_log)) and
+		last;
+	sleep 0.011;
+}
+diag slurp($err_log) if $ENV{V};
+ok(grep(/error reloading/, @l), 'got error reloading');
+open $fh, '>', $err_log;
+close $fh;
+
+($status, $hdr, $bdy) = do_req($srv, 'GET / HTTP/1.0');
+like($status, qr!\AHTTP/1\.[01] 200\b!, 'status line valid afte reload');
+is($bdy, "hello world\n", 'body matches expected after reload');
+
+check_stderr;
+undef $tmpdir; # quiet t/lib.perl END{}
+done_testing;

data/t/reopen-logs.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/reopen-logs.t

@@ -0,0 +1,39 @@
+#!perl -w
+# Copyright (C) unicorn hackers <unicorn-public@yhbt.net>
+# License: GPL-3.0+ <https://www.gnu.org/licenses/gpl-3.0.txt>
+use v5.14; BEGIN { require './t/lib.perl' };
+use autodie;
+my $srv = tcp_server();
+my $u_conf = "$tmpdir/u.conf.rb";
+my $out_log = "$tmpdir/out.log";
+open my $fh, '>', $u_conf;
+print $fh <<EOM;
+stderr_path "$err_log"
+stdout_path "$out_log"
+EOM
+close $fh;
+
+my $auto_reap = unicorn('-c', $u_conf, 't/reopen-logs.ru', { 3 => $srv } );
+my ($status, $hdr, $bdy) = do_req($srv, 'GET / HTTP/1.0');
+is($bdy, "true\n", 'logs opened');
+
+rename($err_log, "$err_log.rot");
+rename($out_log, "$out_log.rot");
+
+$auto_reap->do_kill('USR1');
+
+my $tries = 1000;
+while (!-f $err_log && --$tries) { sleep 0.01 };
+while (!-f $out_log && --$tries) { sleep 0.01 };
+
+ok(-f $out_log, 'stdout_path recreated after USR1');
+ok(-f $err_log, 'stderr_path recreated after USR1');
+
+($status, $hdr, $bdy) = do_req($srv, 'GET / HTTP/1.0');
+is($bdy, "true\n", 'logs reopened with sync==true');
+
+$auto_reap->join('QUIT');
+is($?, 0, 'no error on exit');
+check_stderr;
+undef $tmpdir;
+done_testing;

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/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

data/t/t0012-reload-empty-config.sh

@@ -0,0 +1,86 @@
+#!/bin/sh
+. ./test-lib.sh
+t_plan 9 "reloading unset config resets defaults"
+
+t_begin "setup and start" && {
+	unicorn_setup
+	rtmpfiles unicorn_config_orig before_reload after_reload
+	cat $unicorn_config > $unicorn_config_orig
+	cat >> $unicorn_config <<EOF
+logger Logger.new(STDOUT)
+preload_app true
+timeout 0x7fffffff
+worker_processes 2
+after_fork { |s,w| }
+\$dump_cfg = lambda { |fp,srv|
+  defaults = Unicorn::Configurator::DEFAULTS
+  defaults.keys.map { |x| x.to_s }.sort.each do |key|
+    next if key =~ %r{\Astd(?:err|out)_path\z}
+    key = key.to_sym
+    def_value = defaults[key]
+    srv_value = srv.respond_to?(key) ? srv.__send__(key)
+                                     : srv.instance_variable_get("@#{key}")
+    fp << "#{key}|#{srv_value}|#{def_value}\\n"
+  end
+}
+before_fork { |s,w|
+  File.open("$before_reload", "a") { |fp| \$dump_cfg.call(fp, s) }
+}
+before_exec { |s| }
+EOF
+	unicorn -D -c $unicorn_config env.ru
+	unicorn_wait_start
+}
+
+t_begin "ensure worker is started" && {
+	curl -sSf http://$listen/ > $tmp
+}
+
+t_begin "replace config file with original(-ish)" && {
+	grep -v ^pid < $unicorn_config_orig > $unicorn_config
+	cat >> $unicorn_config <<EOF
+before_fork { |s,w|
+  File.open("$after_reload", "a") { |fp| \$dump_cfg.call(fp, s) }
+}
+EOF
+}
+
+t_begin "reload signal succeeds" && {
+	kill -HUP $unicorn_pid
+	while ! egrep '(done|error) reloading' $r_err >/dev/null
+	do
+		sleep 1
+	done
+	while ! grep reaped < $r_err >/dev/null
+	do
+		sleep 1
+	done
+	grep 'done reloading' $r_err >/dev/null
+}
+
+t_begin "ensure worker is started" && {
+	curl -sSf http://$listen/ > $tmp
+}
+
+t_begin "pid file no longer exists" && {
+	if test -f $pid
+	then
+		die "pid=$pid should not exist"
+	fi
+}
+
+t_begin "killing succeeds" && {
+	kill $unicorn_pid
+}
+
+t_begin "check stderr" && {
+	check_stderr
+}
+
+t_begin "ensure reloading restored settings" && {
+	awk < $after_reload -F'|' '
+$1 != "before_fork" && $2 != $3 { print $0; exit(1) }
+'
+}
+
+t_done

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

@@ -0,0 +1,24 @@
+#!/bin/sh
+. ./test-lib.sh
+t_plan 4 "rewindable_input toggled to false"
+
+t_begin "setup and start" && {
+	unicorn_setup
+	echo rewindable_input false >> $unicorn_config
+	unicorn -D -c $unicorn_config t0013.ru
+	unicorn_wait_start
+}
+
+t_begin "ensure worker is started" && {
+	test xOK = x$(curl -T t0013.ru -H Expect: -vsSf http://$listen/)
+}
+
+t_begin "killing succeeds" && {
+	kill $unicorn_pid
+}
+
+t_begin "check stderr" && {
+	check_stderr
+}
+
+t_done