passenger_dudemeister 3.0.1

data/test/integration_tests/spec_helper.rb

@@ -0,0 +1,19 @@
+source_root = File.expand_path(File.dirname(__FILE__) + "/../..")
+Dir.chdir("#{source_root}/test")
+
+require 'yaml'
+begin
+	CONFIG = YAML::load_file('config.yml')
+rescue Errno::ENOENT
+	STDERR.puts "*** You do not have the file test/config.yml. " <<
+		"Please copy test/config.yml.example to " <<
+		"test/config.yml, and edit it."
+	exit 1
+end
+
+$LOAD_PATH.unshift("#{source_root}/lib")
+$LOAD_PATH.unshift("#{source_root}/test")
+
+require 'phusion_passenger'
+require 'support/test_helper'
+include TestHelper

data/test/oxt/backtrace_test.cpp

@@ -0,0 +1,88 @@
+#include "../tut/tut.h"
+#include "counter.hpp"
+#include <oxt/backtrace.hpp>
+#include <oxt/tracable_exception.hpp>
+#include <oxt/thread.hpp>
+
+using namespace oxt;
+using namespace std;
+
+namespace tut {
+	struct backtrace_test {
+	};
+	
+	DEFINE_TEST_GROUP(backtrace_test);
+
+	TEST_METHOD(1) {
+		// Test TRACE_POINT() and tracable_exception.
+		struct {
+			void foo() {
+				TRACE_POINT();
+				bar();
+			}
+			
+			void bar() {
+				TRACE_POINT();
+				baz();
+			}
+			
+			void baz() {
+				TRACE_POINT();
+				throw tracable_exception();
+			}
+		} object;
+		
+		try {
+			object.foo();
+			fail("tracable_exception expected.");
+		} catch (const tracable_exception &e) {
+			ensure("Backtrace contains foo()",
+				e.backtrace().find("foo()") != string::npos);
+			ensure("Backtrace contains bar()",
+				e.backtrace().find("bar()") != string::npos);
+			ensure("Backtrace contains baz()",
+				e.backtrace().find("baz()") != string::npos);
+		}
+	}
+	
+	static void foo(CounterPtr parent_counter, CounterPtr child_counter) {
+		TRACE_POINT();
+		child_counter->increment();    // Tell parent that we've created the trace point.
+		parent_counter->wait_until(1); // Wait until parent thread says we can exit.
+	}
+	
+	static void bar(CounterPtr parent_counter, CounterPtr child_counter) {
+		TRACE_POINT();
+		child_counter->increment();    // Tell parent that we've created the trace point.
+		parent_counter->wait_until(1); // Wait until parent thread says we can exit.
+	}
+	
+	TEST_METHOD(2) {
+		// Test whether oxt::thread's backtrace support works.
+		CounterPtr parent_counter = Counter::create_ptr();
+		CounterPtr child_counter  = Counter::create_ptr();
+		oxt::thread foo_thread(boost::bind(foo, parent_counter, child_counter));
+		oxt::thread bar_thread(boost::bind(bar, parent_counter, child_counter));
+		
+		// Wait until all threads have created trace points.
+		child_counter->wait_until(2);
+		
+		ensure("Foo thread's backtrace contains foo()",
+			foo_thread.backtrace().find("foo") != string::npos);
+		ensure("Foo thread's backtrace doesn't contain bar()",
+			foo_thread.backtrace().find("bar") == string::npos);
+		ensure("Bar thread's backtrace contains bar()",
+			bar_thread.backtrace().find("bar") != string::npos);
+		ensure("Bar thread's backtrace doesn't contain foo()",
+			bar_thread.backtrace().find("foo") == string::npos);
+		
+		string all_backtraces(oxt::thread::all_backtraces());
+		ensure(all_backtraces.find("foo") != string::npos);
+		ensure(all_backtraces.find("bar") != string::npos);
+		
+		parent_counter->increment(); // Tell threads to quit.
+		foo_thread.join();
+		bar_thread.join();
+	}
+}
+

data/test/oxt/counter.hpp

@@ -0,0 +1,55 @@
+#ifndef _COUNTER_HPP_
+#define _COUNTER_HPP_
+
+#include <boost/shared_ptr.hpp>
+#include <boost/thread.hpp>
+#include <boost/thread/thread_time.hpp>
+
+struct Counter;
+typedef boost::shared_ptr<Counter> CounterPtr;
+
+/**
+ * A synchronization mechanism with counter-like properties.
+ *
+ * To avoid memory corruption when unit tests fail, one should
+ * never store Counter objects on the stack. Instead, one should
+ * create them on the heap and use CounterPtr smart pointers.
+ */
+struct Counter {
+	struct timeout_expired { };
+	
+	unsigned int value;
+	boost::mutex mutex;
+	boost::condition_variable cond;
+	
+	static CounterPtr create_ptr() {
+		return CounterPtr(new Counter());
+	}
+	
+	Counter() {
+		value = 0;
+	}
+	
+	/**
+	 * Wait until other threads have increment this counter to at least wanted_value.
+	 * If this doesn't happen within <tt>timeout</tt> miliseconds, then a timeout_expired
+	 * exception will be thrown.
+	 */
+	void wait_until(unsigned int wanted_value, unsigned int timeout = 1000) {
+		boost::unique_lock<boost::mutex> l(mutex);
+		while (value < wanted_value) {
+			if (!cond.timed_wait(l, boost::get_system_time() + boost::posix_time::milliseconds(timeout))) {
+				throw timeout_expired();
+			}
+		}
+	}
+	
+	/** Increment the counter by one. */
+	void increment() {
+		boost::unique_lock<boost::mutex> l(mutex);
+		value++;
+		cond.notify_all();
+	}
+};
+
+#endif /* _COUNTER_HPP_ */

data/test/oxt/dynamic_thread_group_test.cpp

@@ -0,0 +1,131 @@
+#include "../tut/tut.h"
+#include "counter.hpp"
+#include <boost/bind.hpp>
+#include <boost/thread/thread_time.hpp>
+#include <oxt/dynamic_thread_group.hpp>
+#include <oxt/system_calls.hpp>
+#include <unistd.h>
+
+using namespace boost;
+using namespace oxt;
+
+namespace tut {
+	struct dynamic_thread_group_test {
+		dynamic_thread_group group;
+	};
+	
+	DEFINE_TEST_GROUP(dynamic_thread_group_test);
+	
+	TEST_METHOD(1) {
+		// It has 0 threads in the beginning.
+		ensure_equals(group.num_threads(), 0u);
+	}
+	
+	static void wait_until_done(CounterPtr parent_counter, CounterPtr child_counter) {
+		// Tell parent thread that this thread has started.
+		parent_counter->increment();
+		
+		// Wait until parent says that we can quit.
+		child_counter->wait_until(1);
+	}
+	
+	TEST_METHOD(2) {
+		// Test whether newly created threads are added to the thread
+		// group, and whether they are automatically removed from the
+		// thread group upon termination.
+		
+		// Start 3 'f' threads.
+		CounterPtr f_parent_counter = Counter::create_ptr();
+		CounterPtr f_child_counter  = Counter::create_ptr();
+		boost::function<void()> f(boost::bind(wait_until_done, f_parent_counter, f_child_counter));
+		group.create_thread(f);
+		group.create_thread(f);
+		group.create_thread(f);
+		
+		// Start 1 'g' thread.
+		CounterPtr g_parent_counter = Counter::create_ptr();
+		CounterPtr g_child_counter  = Counter::create_ptr();
+		boost::function<void()> g(boost::bind(wait_until_done, g_parent_counter, g_child_counter));
+		group.create_thread(g);
+		
+		f_parent_counter->wait_until(3); // Wait until all 'f' threads have started.
+		g_parent_counter->wait_until(1); // Wait until the 'g' thread has started.
+		
+		ensure_equals("There are 4 threads in the group", group.num_threads(), 4u);
+		
+		// Tell all 'f' threads that they can quit now.
+		f_child_counter->increment();
+		usleep(25000); // Sleep time must be large enough for Valgrind.
+		ensure_equals(group.num_threads(), 1u);
+		
+		// Tell the 'g' thread that it can quit now.
+		g_child_counter->increment();
+		usleep(25000); // Sleep time must be large enough for Valgrind.
+		ensure_equals(group.num_threads(), 0u);
+	}
+	
+	static void sleep_and_set_true(CounterPtr counter, volatile bool *flag) {
+		// Tell parent thread that this thread has started.
+		counter->increment();
+		try {
+			syscalls::usleep(5000000);
+		} catch (thread_interrupted &) {
+			*flag = true;
+		}
+	}
+	
+	TEST_METHOD(3) {
+		// interrupt_and_join_all() works.
+		
+		// Create two threads.
+		CounterPtr counter = Counter::create_ptr();
+		volatile bool flag1 = false;
+		volatile bool flag2 = false;
+		boost::function<void ()> f(boost::bind(sleep_and_set_true, counter, &flag1));
+		boost::function<void ()> g(boost::bind(sleep_and_set_true, counter, &flag2));
+		group.create_thread(f);
+		group.create_thread(g);
+		// Wait until both threads have started.
+		counter->wait_until(2);
+		
+		// Now interrupt and join them.
+		group.interrupt_and_join_all();
+		// Both threads should have received a thread interruption
+		// request and terminated as a result.
+		ensure_equals(flag1, true);
+		ensure_equals(flag2, true);
+		ensure_equals(group.num_threads(), 0u);
+	}
+	
+	static void do_nothing(unsigned int max) {
+		unsigned int i;
+		for (i = 0; i < max; i++) { }
+	}
+	
+	static void create_threads(dynamic_thread_group *group) {
+		for (int i = 1000; i >= 0; i--) {
+			boost::function<void ()> f(boost::bind(do_nothing, i * 1000));
+			group->create_thread(f, "", 256 * 1024);
+		}
+	}
+	
+	static void interrupt_group(dynamic_thread_group *group) {
+		for (int i = 0; i < 1000; i++) {
+			group->interrupt_and_join_all();
+		}
+	}
+	
+	TEST_METHOD(4) {
+		// Stress test.
+		oxt::thread thr1(boost::bind(create_threads, &group));
+		oxt::thread thr2(boost::bind(interrupt_group, &group));
+		thr1.join();
+		thr2.join();
+		group.interrupt_and_join_all();
+		ensure_equals(group.num_threads(), 0u);
+	}
+	
+	TEST_METHOD(5) {
+		// If the thread function crashes then it will still be correctly removed from the pool.
+	}
+}

data/test/oxt/oxt_test_main.cpp

@@ -0,0 +1,25 @@
+#include "../tut/tut.h"
+#include "../tut/tut_reporter.h"
+#include <oxt/system_calls.hpp>
+#include <signal.h>
+#include <cstdlib>
+
+namespace tut {
+	test_runner_singleton runner;
+}
+
+int main() {
+	tut::reporter reporter;
+	tut::runner.get().set_callback(&reporter);
+	signal(SIGPIPE, SIG_IGN);
+	setenv("RAILS_ENV", "production", 1);
+	setenv("TESTING_PASSENGER", "1", 1);
+	oxt::setup_syscall_interruption_support();
+	try {
+		tut::runner.get().run_tests();
+	} catch (const std::exception &ex) {
+		std::cerr << "Exception raised: " << ex.what() << std::endl;
+		return 1;
+	}
+	return 0;
+}

data/test/oxt/spin_lock_test.cpp

@@ -0,0 +1,59 @@
+#include "../tut/tut.h"
+#include <boost/bind.hpp>
+#include <boost/thread.hpp>
+#include <oxt/spin_lock.hpp>
+
+using namespace boost;
+using namespace oxt;
+
+namespace tut {
+	struct spin_lock_test {
+		boost::mutex continue_mutex;
+		boost::condition_variable continue_cond;
+		bool continue_ok;
+		spin_lock lock;
+		volatile unsigned int counter;
+		
+		spin_lock_test() {
+			counter = 0;
+			continue_ok = false;
+		}
+		
+		void loop_increment(unsigned int inc) {
+			{
+				boost::mutex::scoped_lock l1(continue_mutex);
+				while (!continue_ok) {
+					continue_cond.wait(l1);
+				}
+			}
+			
+			for (unsigned int i = 0; i < inc; i++) {
+				spin_lock::scoped_lock l2(lock);
+				counter++;
+			}
+		}
+	};
+	
+	DEFINE_TEST_GROUP(spin_lock_test);
+
+	TEST_METHOD(1) {
+		boost::thread thr1(boost::bind(&spin_lock_test::loop_increment, this, 100000));
+		boost::thread thr2(boost::bind(&spin_lock_test::loop_increment, this, 100000));
+		boost::thread thr3(boost::bind(&spin_lock_test::loop_increment, this, 100000));
+		boost::thread thr4(boost::bind(&spin_lock_test::loop_increment, this, 100000));
+		
+		{
+			boost::mutex::scoped_lock l(continue_mutex);
+			continue_ok = true;
+			continue_cond.notify_all();
+		}
+		
+		thr1.join();
+		thr2.join();
+		thr3.join();
+		thr4.join();
+		
+		ensure_equals(counter, 400000u);
+	}
+}
+

data/test/oxt/syscall_interruption_test.cpp

@@ -0,0 +1,38 @@
+#include "../tut/tut.h"
+#include <boost/bind.hpp>
+#include <oxt/thread.hpp>
+#include <oxt/system_calls.hpp>
+#include <unistd.h>
+#include <ctime>
+
+using namespace oxt;
+using namespace std;
+
+namespace tut {
+	struct syscall_interruption_test {
+	};
+	
+	DEFINE_TEST_GROUP(syscall_interruption_test);
+	
+	struct SleepFunction {
+		void operator()() {
+			syscalls::usleep(6000000);
+		}
+	};
+	
+	TEST_METHOD(1) {
+		// System call interruption works.
+		SleepFunction s;
+		oxt::thread thr(s);
+		usleep(20000);
+		
+		time_t begin, end, time_spent_in_thread;
+		begin = time(NULL);
+		thr.interrupt_and_join();
+		end = time(NULL);
+		time_spent_in_thread = end - begin;
+		
+		ensure(time_spent_in_thread <= 2);
+	}
+}
+

data/test/ruby/abstract_request_handler_spec.rb

@@ -0,0 +1,406 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'phusion_passenger/abstract_request_handler'
+require 'phusion_passenger/analytics_logger'
+
+require 'fileutils'
+
+module PhusionPassenger
+
+describe AbstractRequestHandler do
+	before :each do
+		preinitialize if respond_to?(:preinitialize)
+		@old_passenger_tmpdir = Utils.passenger_tmpdir
+		Utils.passenger_tmpdir = "abstract_request_handler_spec.tmp"
+		@owner_pipe = IO.pipe
+		@request_handler = AbstractRequestHandler.new(@owner_pipe[1], @options || {})
+		def @request_handler.process_request(*args)
+			# Do nothing.
+		end
+	end
+	
+	after :each do
+		@request_handler.cleanup
+		@owner_pipe[0].close rescue nil
+		Utils.passenger_tmpdir = @old_passenger_tmpdir
+		FileUtils.chmod_R(0777, "abstract_request_handler_spec.tmp")
+		FileUtils.rm_rf("abstract_request_handler_spec.tmp")
+	end
+	
+	def connect(socket_name = :main)
+		if @request_handler.server_sockets[socket_name][1] == "unix"
+			return UNIXSocket.new(@request_handler.server_sockets[socket_name][0])
+		else
+			addr, port = @request_handler.server_sockets[socket_name][0].split(/:/)
+			return TCPSocket.new(addr, port.to_i)
+		end
+	end
+	
+	def send_binary_request(socket, env)
+		channel = MessageChannel.new(socket)
+		data = ""
+		env.each_pair do |key, value|
+			data << key << "\0"
+			data << value << "\0"
+		end
+		channel.write_scalar(data)
+	end
+	
+	it "exits if the owner pipe is closed" do
+		@request_handler.start_main_loop_thread
+		@owner_pipe[0].close
+		eventually do
+			!@request_handler.main_loop_running?
+		end
+	end
+	
+	it "ignores new connections that don't send any data" do
+		def @request_handler.accept_connection
+			return nil
+		end
+		@request_handler.start_main_loop_thread
+		eventually do
+			@request_handler.iterations != 0
+		end
+		@request_handler.processed_requests.should == 0
+	end
+	
+	it "creates a socket file in the Phusion Passenger temp folder, unless when using TCP sockets" do
+		if @request_handler.server_sockets[:main][1] == "unix"
+			File.chmod(0700, "abstract_request_handler_spec.tmp/backends")
+			Dir["abstract_request_handler_spec.tmp/backends/*"].should_not be_empty
+		end
+	end
+	
+	specify "the main socket rejects headers that are too large" do
+		stderr = StringIO.new
+		DebugLogging.log_level = 0
+		DebugLogging.stderr_evaluator = lambda { stderr }
+		@request_handler.start_main_loop_thread
+		begin
+			client = connect
+			client.sync = true
+			block = lambda do
+				data = "REQUEST_METHOD\0/"
+				data << "x" * (AbstractRequestHandler::MAX_HEADER_SIZE * 2)
+				data << "\0"
+				MessageChannel.new(client).write_scalar(data)
+			end
+			block.should raise_error(Errno::EPIPE)
+			stderr.string.should_not be_empty
+		ensure
+			client.close rescue nil
+		end
+	end
+	
+	specify "the main socket rejects unauthenticated connections, if a connect password is supplied" do
+		@request_handler.connect_password = "1234"
+		@request_handler.start_main_loop_thread
+		begin
+			client = connect
+			channel = MessageChannel.new(client)
+			channel.write_scalar("REQUEST_METHOD\0PING\0")
+			client.read.should == ""
+		ensure
+			client.close rescue nil
+		end
+		begin
+			client = connect
+			channel = MessageChannel.new(client)
+			channel.write_scalar("REQUEST_METHOD\0PING\0PASSENGER_CONNECT_PASSWORD\0001234\0")
+			client.read.should == "pong"
+		ensure
+			client.close rescue nil
+		end
+	end
+	
+	it "accepts pings on the main server socket" do
+		@request_handler.start_main_loop_thread
+		client = connect
+		begin
+			channel = MessageChannel.new(client)
+			channel.write_scalar("REQUEST_METHOD\0PING\0")
+			client.read.should == "pong"
+		ensure
+			client.close
+		end
+	end
+	
+	it "accepts pings on the HTTP server socket" do
+		@request_handler.start_main_loop_thread
+		addr, port = @request_handler.server_sockets[:http][0].split(/:/)
+		client = TCPSocket.new(addr, port.to_i)
+		begin
+			client.write("PING / HTTP/1.1\r\n")
+			client.write("Host: foo.com\r\n\r\n")
+			client.close_write
+			client.read.should == "pong"
+		ensure
+			client.close
+		end
+	end
+	
+	specify "the HTTP socket rejects headers that are too large" do
+		stderr = StringIO.new
+		DebugLogging.log_level = 0
+		DebugLogging.stderr_evaluator = lambda { stderr }
+		@request_handler.start_main_loop_thread
+		begin
+			client = connect(:http)
+			client.sync = true
+			block = lambda do
+				client.write("GET /")
+				client.write("x" * AbstractRequestHandler::MAX_HEADER_SIZE)
+				sleep 0.01 # Context switch
+				client.write("x" * AbstractRequestHandler::MAX_HEADER_SIZE)
+				client.write(" HTTP/1.1\r\n")
+			end
+			block.should raise_error(SystemCallError)
+			stderr.string.should_not be_empty
+		ensure
+			client.close rescue nil
+		end
+	end
+	
+	specify "the HTTP socket rejects unauthenticated connections, if a connect password is supplied" do
+		DebugLogging.log_level = -1
+		@request_handler.connect_password = "1234"
+		@request_handler.start_main_loop_thread
+		begin
+			client = connect(:http)
+			client.write("PING / HTTP/1.1\r\n")
+			client.write("\r\n")
+			client.read.should == ""
+		ensure
+			client.close rescue nil
+		end
+		begin
+			client = connect(:http)
+			client.write("PING / HTTP/1.1\r\n")
+			client.write("X-Passenger-Connect-Password: 1234\r\n")
+			client.write("\r\n")
+			client.read.should == "pong"
+		ensure
+			client.close rescue nil
+		end
+	end
+	
+	describe "if analytics logger is given" do
+		def preinitialize
+			if @agent_pid
+				Process.kill('KILL', @agent_pid)
+				Process.waitpid(@agent_pid)
+			end
+			@log_dir = Utils.passenger_tmpdir
+			@logging_agent_password = "1234"
+			@agent_pid, @socket_filename, @socket_address = spawn_logging_agent(@log_dir,
+				@logging_agent_password)
+			
+			@logger = AnalyticsLogger.new(@socket_address, "logging",
+				"1234", "localhost")
+			@options = { "analytics_logger" => @logger }
+		end
+		
+		after :each do
+			if @agent_pid
+				Process.kill('KILL', @agent_pid)
+				Process.waitpid(@agent_pid)
+			end
+		end
+		
+		def base64(data)
+			return [data].pack('m').gsub("\n", "")
+		end
+		
+		it "makes the analytics log object available through the request env and a thread-local variable" do
+			header_value = nil
+			thread_value = nil
+			@request_handler.should_receive(:process_request).and_return do |headers, input, output, status_line_desired|
+				header_value = headers[PASSENGER_ANALYTICS_WEB_LOG]
+				thread_value = Thread.current[PASSENGER_ANALYTICS_WEB_LOG]
+			end
+			@request_handler.start_main_loop_thread
+			client = connect
+			begin
+				send_binary_request(client,
+					"REQUEST_METHOD" => "GET",
+					"PASSENGER_TXN_ID" => "1234-abcd",
+					"PASSENGER_GROUP_NAME" => "foobar")
+				client.read
+			ensure
+				client.close
+			end
+			header_value.should be_kind_of(AnalyticsLogger::Log)
+			thread_value.should be_kind_of(AnalyticsLogger::Log)
+			header_value.should == thread_value
+		end
+		
+		it "logs uncaught exceptions for requests that have a transaction ID" do
+			@request_handler.should_receive(:process_request).and_return do |headers, input, output, status_line_desired|
+				raise "something went wrong"
+			end
+			@request_handler.start_main_loop_thread
+			client = connect
+			begin
+				DebugLogging.log_level = -2
+				send_binary_request(client,
+					"REQUEST_METHOD" => "GET",
+					"PASSENGER_TXN_ID" => "1234-abcd",
+					"PASSENGER_GROUP_NAME" => "foobar")
+			ensure
+				client.close
+			end
+			eventually(5) do
+				flush_logging_agent(@logging_agent_password, @socket_address)
+				log_file = Dir["#{@log_dir}/1/*/*/exceptions/**/log.txt"].first
+				if log_file
+					log_data = File.read(log_file)
+				else
+					log_data = ""
+				end
+				log_data.include?("Request transaction ID: 1234-abcd\n") &&
+					log_data.include?("Message: " + base64("something went wrong")) &&
+					log_data.include?("Class: RuntimeError") &&
+					log_data.include?("Backtrace: ")
+			end
+		end
+	end
+	
+	describe "HTTP parsing" do
+		before :each do
+			@request_handler.start_main_loop_thread
+			addr, port = @request_handler.server_sockets[:http][0].split(/:/)
+			port = port.to_i
+			@client = TCPSocket.new(addr, port)
+			@client.sync = true
+		end
+		
+		after :each do
+			@client.close
+		end
+		
+		it "correctly parses HTTP requests without query string" do
+			@request_handler.should_receive(:process_request).and_return do |headers, input, output, status_line_desired|
+				headers["REQUEST_METHOD"].should == "POST"
+				headers["SERVER_PROTOCOL"].should == "HTTP/1.1"
+				headers["HTTP_HOST"].should == "foo.com"
+				headers["HTTP_X_FOO_BAR"].should == "baz"
+				headers["PATH_INFO"].should == "/foo/bar"
+				headers["SCRIPT_NAME"].should == ""
+				headers["QUERY_STRING"].should == ""
+				headers["REQUEST_URI"].should == "/foo/bar"
+				headers["HTTP_CONTENT_LENGTH"].should be_nil
+				headers["HTTP_CONTENT_TYPE"].should be_nil
+				headers["CONTENT_LENGTH"].should == "10"
+				headers["CONTENT_TYPE"].should == "text/plain"
+			end
+			
+			@client.write("POST /foo/bar HTTP/1.1\r\n")
+			@client.write("Host: foo.com\r\n")
+			@client.write("X-Foo-Bar: baz\r\n")
+			@client.write("Content-Length: 10\r\n")
+			@client.write("Content-Type: text/plain\r\n")
+			@client.write("\r\n")
+			@client.close_write
+			@client.read
+		end
+		
+		it "correctly parses HTTP requests with query string" do
+			@request_handler.should_receive(:process_request).and_return do |headers, input, output, status_line_desired|
+				headers["REQUEST_METHOD"].should == "POST"
+				headers["SERVER_PROTOCOL"].should == "HTTP/1.1"
+				headers["HTTP_HOST"].should == "foo.com"
+				headers["HTTP_X_FOO_BAR"].should == "baz"
+				headers["PATH_INFO"].should == "/foo/bar"
+				headers["SCRIPT_NAME"].should == ""
+				headers["QUERY_STRING"].should == "hello=world&a=b+c"
+				headers["REQUEST_URI"].should == "/foo/bar?hello=world&a=b+c"
+				headers["HTTP_CONTENT_LENGTH"].should be_nil
+				headers["HTTP_CONTENT_TYPE"].should be_nil
+				headers["CONTENT_LENGTH"].should == "10"
+				headers["CONTENT_TYPE"].should == "text/plain"
+			end
+			
+			@client.write("POST /foo/bar?hello=world&a=b+c HTTP/1.1\r\n")
+			@client.write("Host: foo.com\r\n")
+			@client.write("X-Foo-Bar: baz\r\n")
+			@client.write("Content-Length: 10\r\n")
+			@client.write("Content-Type: text/plain\r\n")
+			@client.write("\r\n")
+			@client.close_write
+			@client.read
+		end
+		
+		it "correct parses HTTP requests that come in arbitrary chunks" do
+			@request_handler.should_receive(:process_request).and_return do |headers, input, output, status_line_desired|
+				headers["REQUEST_METHOD"].should == "POST"
+				headers["SERVER_PROTOCOL"].should == "HTTP/1.1"
+				headers["HTTP_HOST"].should == "foo.com"
+				headers["HTTP_X_FOO_BAR"].should == "baz"
+				headers["PATH_INFO"].should == "/foo/bar"
+				headers["SCRIPT_NAME"].should == ""
+				headers["QUERY_STRING"].should == "hello=world&a=b+c"
+				headers["REQUEST_URI"].should == "/foo/bar?hello=world&a=b+c"
+				headers["HTTP_CONTENT_LENGTH"].should be_nil
+				headers["HTTP_CONTENT_TYPE"].should be_nil
+				headers["CONTENT_LENGTH"].should == "10"
+				headers["CONTENT_TYPE"].should == "text/plain"
+				headers["HTTP_PLUS_SOME"].should be_nil
+			end
+			
+			@client.write("POST /fo")
+			sleep 0.001
+			@client.write("o/bar?hello=world&a=b+c HT")
+			sleep 0.001
+			@client.write("TP/1.1\r")
+			sleep 0.001
+			@client.write("\nHost: foo.com")
+			sleep 0.001
+			@client.write("\r\n")
+			sleep 0.001
+			@client.write("X-Foo-Bar: baz\r\n")
+			sleep 0.001
+			@client.write("Content-Len")
+			sleep 0.001
+			@client.write("gth: 10\r\nContent-Type: text/pla")
+			sleep 0.001
+			@client.write("in\r\n\r")
+			sleep 0.001
+			@client.write("\nPlus-Some: garbage data that should be ignored.")
+			@client.close_write
+			@client.read
+		end
+	end
+	
+	specify "upon receiving a soft shutdown signal, the main loop quits a while after the last connection was accepted" do
+		@request_handler.soft_termination_linger_time = 0.2
+		@request_handler.start_main_loop_thread
+		@request_handler.soft_shutdown
+		
+		# Each time we ping the server it should reset the exit time.
+		deadline = Time.now + 0.6
+		while Time.now < deadline
+			@request_handler.should be_main_loop_running
+			client = connect
+			begin
+				channel = MessageChannel.new(client)
+				channel.write_scalar("REQUEST_METHOD\0PING\0")
+				client.read
+				sleep 0.02
+			ensure
+				client.close
+			end
+		end
+		@request_handler.should be_main_loop_running
+		
+		# After we're done pinging it should quit within a short period of time.
+		deadline = Time.now + 0.6
+		while Time.now < deadline && @request_handler.main_loop_running?
+			sleep 0.01
+		end
+		@request_handler.should_not be_main_loop_running
+	end
+	
+	############################
+end
+
+end # module PhusionPassenger