unicorn-maintained 6.2.0

data/t/t0013.ru

@@ -0,0 +1,12 @@
+#\ -E none
+use Rack::ContentLength
+use Rack::ContentType, 'text/plain'
+app = lambda do |env|
+  case env['rack.input']
+  when Unicorn::StreamInput
+    [ 200, {}, %w(OK) ]
+  else
+    [ 500, {}, %w(NO) ]
+  end
+end
+run app

data/t/t0014-rewindable-input-true.sh

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

data/t/t0014.ru

@@ -0,0 +1,12 @@
+#\ -E none
+use Rack::ContentLength
+use Rack::ContentType, 'text/plain'
+app = lambda do |env|
+  case env['rack.input']
+  when Unicorn::TeeInput
+    [ 200, {}, %w(OK) ]
+  else
+    [ 500, {}, %w(NO) ]
+  end
+end
+run app

data/t/t0015-configurator-internals.sh

@@ -0,0 +1,25 @@
+#!/bin/sh
+. ./test-lib.sh
+t_plan 4 "configurator internals tests (from FAQ)"
+
+t_begin "setup and start" && {
+	unicorn_setup
+	cat >> $unicorn_config <<EOF
+HttpRequest::DEFAULTS["rack.url_scheme"] = "https"
+Configurator::DEFAULTS[:logger].formatter = Logger::Formatter.new
+EOF
+	unicorn -D -c $unicorn_config env.ru
+	unicorn_wait_start
+}
+
+t_begin "single request" && {
+	curl -sSfv http://$listen/ | grep '"rack.url_scheme"=>"https"'
+}
+
+t_begin "killing succeeds" && {
+	kill $unicorn_pid
+}
+
+t_begin "no errors" && check_stderr
+
+t_done

data/t/t0020-at_exit-handler.sh

@@ -0,0 +1,49 @@
+#!/bin/sh
+. ./test-lib.sh
+
+t_plan 5 "at_exit/END handlers work as expected"
+
+t_begin "setup and startup" && {
+	unicorn_setup
+	cat >> $unicorn_config <<EOF
+at_exit { \$stdout.syswrite("#{Process.pid} BOTH\\n") }
+END { \$stdout.syswrite("#{Process.pid} END BOTH\\n") }
+after_fork do |_,_|
+  at_exit { \$stdout.syswrite("#{Process.pid} WORKER ONLY\\n") }
+  END { \$stdout.syswrite("#{Process.pid} END WORKER ONLY\\n") }
+end
+EOF
+
+	unicorn -D pid.ru -c $unicorn_config
+	unicorn_wait_start
+}
+
+t_begin "read worker PID" && {
+	worker_pid=$(curl -sSf http://$listen/)
+	t_info "worker_pid=$worker_pid"
+}
+
+t_begin "issue graceful shutdown (SIGQUIT) and wait for termination" && {
+	kill -QUIT $unicorn_pid
+
+	while kill -0 $unicorn_pid >/dev/null 2>&1
+	do
+		sleep 1
+	done
+}
+
+t_begin "check stderr" && check_stderr
+
+dbgcat r_err
+dbgcat r_out
+
+t_begin "all at_exit handlers ran" && {
+	grep "$worker_pid BOTH" $r_out
+	grep "$unicorn_pid BOTH" $r_out
+	grep "$worker_pid END BOTH" $r_out
+	grep "$unicorn_pid END BOTH" $r_out
+	grep "$worker_pid WORKER ONLY" $r_out
+	grep "$worker_pid END WORKER ONLY" $r_out
+}
+
+t_done

data/t/t0021-process_detach.sh

@@ -0,0 +1,29 @@
+#!/bin/sh
+. ./test-lib.sh
+
+t_plan 5 "Process.detach on forked background process works"
+
+t_begin "setup and startup" && {
+	t_fifos process_detach
+	unicorn_setup
+	TEST_FIFO=$process_detach \
+	  unicorn -E none -D detach.ru -c $unicorn_config
+	unicorn_wait_start
+}
+
+t_begin "read detached PID with HTTP/1.0" && {
+	detached_pid=$(curl -0 -sSf http://$listen/)
+	t_info "detached_pid=$detached_pid"
+}
+
+t_begin "read background FIFO" && {
+	test xHIHI = x"$(cat $process_detach)"
+}
+
+t_begin "killing succeeds" && {
+	kill $unicorn_pid
+}
+
+t_begin "check stderr" && check_stderr
+
+t_done

data/t/t0022-listener_names-preload_app.sh

@@ -0,0 +1,32 @@
+#!/bin/sh
+. ./test-lib.sh
+
+# Raindrops::Middleware depends on Unicorn.listener_names,
+# ensure we don't break Raindrops::Middleware when preload_app is true
+
+t_plan 4 "Unicorn.listener_names available with preload_app=true"
+
+t_begin "setup and startup" && {
+	unicorn_setup
+	echo preload_app true >> $unicorn_config
+	unicorn -E none -D listener_names.ru -c $unicorn_config
+	unicorn_wait_start
+}
+
+t_begin "read listener names includes listener" && {
+	resp=$(curl -sSf http://$listen/)
+	ok=false
+	t_info "resp=$resp"
+	case $resp in
+	*\"$listen\"*) ok=true ;;
+	esac
+	$ok
+}
+
+t_begin "killing succeeds" && {
+	kill $unicorn_pid
+}
+
+t_begin "check stderr" && check_stderr
+
+t_done

data/t/t0300-no-default-middleware.sh

@@ -0,0 +1,20 @@
+#!/bin/sh
+. ./test-lib.sh
+t_plan 3 "test the -N / --no-default-middleware option"
+
+t_begin "setup and start" && {
+	unicorn_setup
+	unicorn -N -D -c $unicorn_config fails-rack-lint.ru
+	unicorn_wait_start
+}
+
+t_begin "check exit status with Rack::Lint not present" && {
+	test 500 -ne "$(curl -sf -o/dev/null -w'%{http_code}' http://$listen/)"
+}
+
+t_begin "killing succeeds" && {
+	kill $unicorn_pid
+	check_stderr
+}
+
+t_done

data/t/t0301-no-default-middleware-ignored-in-config.sh

@@ -0,0 +1,25 @@
+#!/bin/sh
+. ./test-lib.sh
+t_plan 3 "-N / --no-default-middleware option not supported in config.ru"
+
+t_begin "setup and start" && {
+	unicorn_setup
+	RACK_ENV=development unicorn -D -c $unicorn_config t0301.ru
+	unicorn_wait_start
+}
+
+t_begin "check switches parsed as expected and -N ignored for Rack::Lint" && {
+	debug=false
+	lint=
+	eval "$(curl -sf http://$listen/vars)"
+	test x"$debug" = xtrue
+	test x"$lint" != x
+	test -f "$lint"
+}
+
+t_begin "killing succeeds" && {
+	kill $unicorn_pid
+	check_stderr
+}
+
+t_done

data/t/t0301.ru

@@ -0,0 +1,13 @@
+#\-N --debug
+run(lambda do |env|
+  case env['PATH_INFO']
+  when '/vars'
+    b = "debug=#{$DEBUG.inspect}\n" \
+        "lint=#{caller.grep(%r{rack/lint\.rb})[0].split(':')[0]}\n"
+  end
+  h = {
+    'content-length' => b.size.to_s,
+    'content-type' => 'text/plain',
+  }
+  [ 200, h, [ b ] ]
+end)

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 -QUIT $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 -QUIT $unicorn_pid
+}
+
+t_begin "check_stderr" && check_stderr
+
+t_done

data/t/test-lib.sh

@@ -0,0 +1,125 @@
+#!/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
+}
+
+# "unix_time" is not in POSIX, but in GNU, and FreeBSD 9.0 (possibly earlier)
+unix_time () {
+	$RUBY -e 'puts Time.now.to_i'
+}
+
+# "wc -l" outputs leading whitespace on *BSDs, filter it out for portability
+count_lines () {
+	wc -l | tr -d '[:space:]'
+}
+
+# "wc -c" outputs leading whitespace on *BSDs, filter it out for portability
+count_bytes () {
+	wc -c | tr -d '[:space:]'
+}
+
+# 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" |count_bytes) -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 | \
+		grep -v NameError.*Unicorn::Waiter
+	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][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)
+}

data/t/winch_ttin.t

@@ -0,0 +1,67 @@
+#!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;
+use POSIX qw(mkfifo);
+my $u_conf = "$tmpdir/u.conf.rb";
+my $u_sock = "$tmpdir/u.sock";
+my $fifo = "$tmpdir/fifo";
+mkfifo($fifo, 0666) or die "mkfifo($fifo): $!";
+
+open my $fh, '>', $u_conf;
+print $fh <<EOM;
+pid "$tmpdir/pid"
+listen "$u_sock"
+stderr_path "$err_log"
+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
+EOM
+close $fh;
+
+unicorn('-D', '-c', $u_conf, 't/integration.ru')->join;
+is($?, 0, 'daemonized properly');
+open $fh, '<', "$tmpdir/pid";
+chomp(my $pid = <$fh>);
+ok(kill(0, $pid), 'daemonized PID works');
+my $quit = sub { kill('QUIT', $pid) if $pid; $pid = undef };
+END { $quit->() };
+
+open $fh, '<', $fifo;
+my $worker_nr = <$fh>;
+close $fh;
+is($worker_nr, '0', 'initial worker spawned');
+
+my ($status, $hdr, $worker_pid) = do_req($u_sock, 'GET /pid HTTP/1.0');
+like($status, qr/ 200\b/, 'got 200 response');
+like($worker_pid, qr/\A[0-9]+\n\z/s, 'PID in response');
+chomp $worker_pid;
+ok(kill(0, $worker_pid), 'worker_pid is valid');
+
+ok(kill('WINCH', $pid), 'SIGWINCH can be sent');
+
+my $tries = 1000;
+while (CORE::kill(0, $worker_pid) && --$tries) { sleep 0.01 }
+ok(!CORE::kill(0, $worker_pid), 'worker not running');
+
+ok(kill('TTIN', $pid), 'SIGTTIN to restart worker');
+
+open $fh, '<', $fifo;
+$worker_nr = <$fh>;
+close $fh;
+is($worker_nr, '0', 'worker restarted');
+
+($status, $hdr, my $new_worker_pid) = do_req($u_sock, 'GET /pid HTTP/1.0');
+like($status, qr/ 200\b/, 'got 200 response');
+like($new_worker_pid, qr/\A[0-9]+\n\z/, 'got new worker PID');
+chomp $new_worker_pid;
+ok(kill(0, $new_worker_pid), 'got a valid worker PID');
+isnt($worker_pid, $new_worker_pid, 'worker PID changed');
+
+$quit->();
+
+check_stderr;
+undef $tmpdir;
+done_testing;

data/t/working_directory.t

@@ -0,0 +1,94 @@
+#!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;
+mkdir "$tmpdir/alt";
+my $ru = "$tmpdir/alt/config.ru";
+open my $fh, '>', $u_conf;
+print $fh <<EOM;
+pid "$pid_file"
+preload_app true
+stderr_path "$err_log"
+working_directory "$tmpdir/alt" # the whole point of this test
+before_fork { |_,_| \$master_ppid = Process.ppid }
+EOM
+close $fh;
+
+my $common_ru = <<'EOM';
+use Rack::ContentLength
+use Rack::ContentType, 'text/plain'
+run lambda { |env| [ 200, {}, [ "#{$master_ppid}\n" ] ] }
+EOM
+
+open $fh, '>', $ru;
+print $fh <<EOM;
+#\\--daemonize --listen $u_sock
+$common_ru
+EOM
+close $fh;
+
+unicorn('-c', $u_conf)->join; # will daemonize
+chomp($daemon_pid = slurp($pid_file));
+
+my ($status, $hdr, $bdy) = do_req($u_sock, 'GET / HTTP/1.0');
+is($bdy, "1\n", 'got expected $master_ppid');
+
+stop_daemon;
+check_stderr;
+
+if ('test without CLI switches in config.ru') {
+	truncate $err_log, 0;
+	open $fh, '>', $ru;
+	print $fh $common_ru;
+	close $fh;
+
+	unicorn('-D', '-l', $u_sock, '-c', $u_conf)->join; # will daemonize
+	chomp($daemon_pid = slurp($pid_file));
+
+	($status, $hdr, $bdy) = do_req($u_sock, 'GET / HTTP/1.0');
+	is($bdy, "1\n", 'got expected $master_ppid');
+
+	stop_daemon;
+	check_stderr;
+}
+
+if ('ensures broken working_directory (missing config.ru) is OK') {
+	truncate $err_log, 0;
+	unlink $ru;
+
+	my $auto_reap = unicorn('-c', $u_conf);
+	$auto_reap->join;
+	isnt($?, 0, 'exited with error due to missing config.ru');
+
+	like(slurp($err_log), qr/rackup file \Q(config.ru)\E not readable/,
+		'noted unreadability of config.ru in stderr');
+}
+
+if ('fooapp.rb (not config.ru) works with working_directory') {
+	truncate $err_log, 0;
+	my $fooapp = "$tmpdir/alt/fooapp.rb";
+	open $fh, '>', $fooapp;
+	print $fh <<EOM;
+class Fooapp
+  def self.call(env)
+    b = "dir=#{Dir.pwd}"
+    h = { 'content-type' => 'text/plain', 'content-length' => b.bytesize.to_s }
+    [ 200, h, [ b ] ]
+  end
+end
+EOM
+	close $fh;
+	my $srv = tcp_server;
+	my $auto_reap = unicorn(qw(-c), $u_conf, qw(-I. fooapp.rb),
+				{ -C => '/', 3 => $srv });
+	($status, $hdr, $bdy) = do_req($srv, 'GET / HTTP/1.0');
+	is($bdy, "dir=$tmpdir/alt",
+		'fooapp.rb (w/o config.ru) w/ working_directory');
+	$auto_reap->join('TERM');
+	is($?, 0, 'fooapp.rb process exited');
+	check_stderr;
+}
+
+undef $tmpdir;
+done_testing;

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)
+}