passenger 3.0.21 → 3.9.1.beta

data/test/cxx/FileChangeCheckerTest.cpp

@@ -40,14 +40,14 @@ namespace tut {
 			TempDir d("test.tmp");
 			touchFile("test.tmp/test.txt");
 			
-			system("chmod a= test.tmp");
+			runShellCommand("chmod a= test.tmp");
 			ensure(!checker.changed("test.tmp/test.txt"));
 			
 			// Should still be false.
 			ensure(!checker.changed("test.tmp/test.txt"));
 			
 			// Now make it accessible again...
-			system("chmod u=rwx test.tmp");
+			runShellCommand("chmod u=rwx test.tmp");
 			ensure(checker.changed("test.tmp/test.txt"));
 		}
 	}
@@ -90,20 +90,20 @@ namespace tut {
 	}
 	
 	TEST_METHOD(6) {
-		// File is changed if existed but has now been deleted.
+		// File is not changed if existed and has now been deleted.
 		FileChangeChecker checker(10);
 		
 		touchFile("test.txt");
 		checker.changed("test.txt");
 		unlink("test.txt");
-		ensure("test.txt is considered changed if it has been deleted",
-			checker.changed("test.txt"));
+		ensure("test.txt is not considered changed if it has been deleted",
+			!checker.changed("test.txt"));
 		
 		touchFile("test2.txt");
 		checker.changed("test2.txt");
 		unlink("test2.txt");
-		ensure("test2.txt is considered changed if it has been deleted",
-			checker.changed("test2.txt"));
+		ensure("test2.txt is not considered changed if it has been deleted",
+			!checker.changed("test2.txt"));
 	}
 	
 	TEST_METHOD(7) {
@@ -138,11 +138,11 @@ namespace tut {
 			checker.changed("test.tmp/test.txt");
 			
 			touchFile("test.tmp/test.txt", 2);
-			system("chmod a= test.tmp");
+			runShellCommand("chmod a= test.tmp");
 			ensure("First check returns false", !checker.changed("test.tmp/test.txt"));
 			
 			// Now make it accessible again...
-			system("chmod u=rwx test.tmp");
+			runShellCommand("chmod u=rwx test.tmp");
 			ensure("Second check returns true", checker.changed("test.tmp/test.txt"));
 		}
 	}
@@ -201,14 +201,14 @@ namespace tut {
 			
 			FileChangeChecker checker(10);
 			TempDir d("test.tmp");
-			touchFile("test.tmp/test.txt");
+			touchFile("test.tmp/test.txt", 1);
 			
 			checker.changed("test.tmp/test.txt");
-			unlink("test.tmp/test.txt");
-			system("chmod a= test.tmp");
-			ensure(!checker.changed("test.tmp/test.txt"));
-			system("chmod u=rwx test.tmp");
-			ensure(checker.changed("test.tmp/test.txt"));
+			touchFile("test.tmp/test.txt", 2);
+			runShellCommand("chmod a= test.tmp");
+			ensure("(1)", !checker.changed("test.tmp/test.txt"));
+			runShellCommand("chmod u=rwx test.tmp");
+			ensure("(2)", checker.changed("test.tmp/test.txt"));
 		}
 	}
 	
@@ -228,9 +228,11 @@ namespace tut {
 		unlink("test.txt");
 		unlink("test2.txt");
 		unlink("test3.txt");
-		ensure("test2.txt is still in the file list", checker.changed("test2.txt"));
-		ensure("test3.txt is still in the file list", checker.changed("test3.txt"));
-		ensure("test.txt is removed from the file list", !checker.changed("test.txt"));
+		ensure("test2.txt is still in the file list", checker.knows("test2.txt"));
+		ensure("test2.txt is not considered changed", !checker.changed("test2.txt"));
+		ensure("test3.txt is still in the file list", checker.knows("test3.txt"));
+		ensure("test3.txt is not considered changed", !checker.changed("test3.txt"));
+		ensure("test.txt is removed from the file list", !checker.knows("test.txt"));
 	}
 	
 	TEST_METHOD(14) {

data/test/cxx/FilterSupportTest.cpp

@@ -1,5 +1,5 @@
 #include "TestSupport.h"
-#include "LoggingAgent/FilterSupport.h"
+#include "agents/LoggingAgent/FilterSupport.h"
 
 #include <boost/bind.hpp>
 #include <boost/shared_ptr.hpp>
@@ -159,13 +159,13 @@ namespace tut {
 	TEST_METHOD(15) {
 		// String begin and end quote characters must match.
 		try {
-			Filter("uri == 'hello world\"");
+			(void) Filter("uri == 'hello world\"");
 			fail("Syntax error expected");
 		} catch (const SyntaxError &) {
 			// Pass.
 		}
 		try {
-			Filter("uri == \"hello world'");
+			(void) Filter("uri == \"hello world'");
 			fail("Syntax error expected");
 		} catch (const SyntaxError &) {
 			// Pass.
@@ -177,13 +177,13 @@ namespace tut {
 		ctx.uri = "hello world";
 		ensure(Filter("uri =~ %r{hello}").run(ctx));
 		try {
-			Filter("uri =~ /hello}");
+			(void) Filter("uri =~ /hello}");
 			fail("Syntax error expected");
 		} catch (const SyntaxError &) {
 			// Pass.
 		}
 		try {
-			Filter("uri =~ %r{hello/");
+			(void) Filter("uri =~ %r{hello/");
 			fail("Syntax error expected");
 		} catch (const SyntaxError &) {
 			// Pass.

data/test/cxx/IOUtilsTest.cpp

@@ -475,9 +475,16 @@ namespace tut {
 		Pipe p = createPipe();
 		unsigned long long startTime = SystemTime::getUsec();
 		unsigned long long timeout = 30000;
+		char data1[1024], data2[1024];
+		StaticString data[] = {
+			StaticString(data1, sizeof(data1) - 1),
+			StaticString(data2, sizeof(data2) - 1)
+		};
+		memset(data1, 'x', sizeof(data1));
+		memset(data2, 'y', sizeof(data2));
+
 		try {
-			StaticString data[] = { "hello", "world" };
-			for (int i = 0; i < 1024 * 1024; i++) {
+			for (int i = 0; i < 1024; i++) {
 				gatheredWrite(p[1], data, 2, &timeout);
 			}
 			fail("TimeoutException expected");
@@ -804,7 +811,7 @@ namespace tut {
 		SocketPair sockets = createUnixSocketPair();
 		Pipe pipes = createPipe();
 		writeFileDescriptor(sockets[0], pipes[1]);
-		FileDescriptor fd = readFileDescriptor(sockets[1]);
+		FileDescriptor fd(readFileDescriptor(sockets[1]));
 		writeExact(fd, "hello");
 		char buf[6];
 		ensure_equals(readExact(pipes[0], buf, 5), 5u);
@@ -820,7 +827,7 @@ namespace tut {
 		unsigned long long timeout = 30000;
 		unsigned long long startTime = SystemTime::getUsec();
 		try {
-			FileDescriptor fd = readFileDescriptor(sockets[0], &timeout);
+			FileDescriptor fd(readFileDescriptor(sockets[0], &timeout));
 			fail("TimeoutException expected");
 		} catch (const TimeoutException &) {
 			unsigned long long elapsed = SystemTime::getUsec() - startTime;

data/test/cxx/MessageReadersWritersTest.cpp

@@ -1,4 +1,4 @@
-#include "TestSupport.h"
+#include <TestSupport.h>
 #include <MessageReadersWriters.h>
 #include <cstdlib>
 #include <alloca.h>

data/test/cxx/MessageServerTest.cpp

@@ -4,7 +4,7 @@
 #include <boost/bind.hpp>
 
 #include "MessageServer.h"
-#include "ApplicationPool/Client.h"
+#include "MessageClient.h"
 #include "Utils.h"
 #include <string>
 #include <cstring>
@@ -12,7 +12,6 @@
 #include <errno.h>
 
 using namespace Passenger;
-using namespace Passenger::ApplicationPool;
 using namespace boost;
 using namespace std;
 
@@ -21,6 +20,7 @@ namespace tut {
 		ServerInstanceDirPtr serverInstanceDir;
 		ServerInstanceDir::GenerationPtr generation;
 		string socketFilename;
+		string socketAddress;
 		AccountsDatabasePtr accountsDatabase;
 		AccountPtr clientAccount;
 		shared_ptr<MessageServer> server;
@@ -29,6 +29,7 @@ namespace tut {
 		MessageServerTest() {
 			createServerInstanceDirAndGeneration(serverInstanceDir, generation);
 			socketFilename = generation->getPath() + "/socket";
+			socketAddress = "unix:" + socketFilename;
 			accountsDatabase = ptr(new AccountsDatabase());
 			clientAccount = accountsDatabase->add("test", "12345", false);
 			
@@ -45,40 +46,40 @@ namespace tut {
 			Passenger::setLogLevel(0);
 		}
 		
-		class SlowClient: public Client {
+		class SlowClient: public MessageClient {
 		private:
 			unsigned int timeToSendUsername;
 			unsigned int timeToSendPassword;
 			
 		protected:
-			virtual void sendUsername(MessageChannel &channel, const string &username) {
+			virtual void sendUsername(int fd, const StaticString &username, unsigned long long *timeout) {
 				if (timeToSendUsername > 0) {
 					usleep(timeToSendUsername * 1000);
 				}
-				channel.writeScalar(username);
+				writeScalarMessage(fd, username);
 			}
 
-			virtual void sendPassword(MessageChannel &channel, const StaticString &userSuppliedPassword) {
+			virtual void sendPassword(int fd, const StaticString &userSuppliedPassword, unsigned long long *timeout) {
 				if (timeToSendPassword > 0) {
 					usleep(timeToSendPassword * 1000);
 				}
-				channel.writeScalar(userSuppliedPassword.c_str(), userSuppliedPassword.size());
+				writeScalarMessage(fd, userSuppliedPassword);
 			}
 			
 		public:
 			SlowClient(unsigned int timeToSendUsername,
 			           unsigned int timeToSendPassword)
-			         : Client()
+			         : MessageClient()
 			{
 				this->timeToSendUsername = timeToSendUsername;
 				this->timeToSendPassword = timeToSendPassword;
 			}
 		};
 		
-		class CustomClient: public Client {
+		class CustomClient: public MessageClient {
 		public:
 			CustomClient *sendText(const string &text) {
-				data->channel.write(text.c_str(), NULL);
+				write(text.c_str(), NULL);
 				return this;
 			}
 		};
@@ -153,19 +154,19 @@ namespace tut {
 		accountsDatabase->add("hashed_user", Account::createHash("67890"), true);
 		
 		try {
-			Client().connect(socketFilename, "testt", "12345");
+			MessageClient().connect(socketAddress, "testt", "12345");
 			fail("SecurityException expected when invalid username is given");
 		} catch (const SecurityException &) {
 			// Pass.
 		}
 		try {
-			Client().connect(socketFilename, "test", "123456");
+			MessageClient().connect(socketAddress, "test", "123456");
 			fail("SecurityException expected when invalid password is given for an account with plain text password");
 		} catch (const SecurityException &) {
 			// Pass.
 		}
 		try {
-			Client().connect(socketFilename, "test", "678900");
+			MessageClient().connect(socketAddress, "test", "678900");
 			fail("SecurityException expected when invalid password is given for an account with hashed password");
 		} catch (const SecurityException &) {
 			// Pass.
@@ -175,14 +176,14 @@ namespace tut {
 	TEST_METHOD(2) {
 		// It supports hashed passwords.
 		accountsDatabase->add("hashed_user", Account::createHash("67890"), true);
-		Client().connect(socketFilename, "hashed_user", "67890"); // Should not throw exception.
+		MessageClient().connect(socketAddress, "hashed_user", "67890"); // Should not throw exception.
 	}
 	
 	TEST_METHOD(3) {
 		// It disconnects the client if the client does not supply a username and
 		// password within a time limit.
 		Passenger::setLogLevel(-1);
-		server->setLoginTimeout(40000);
+		server->setLoginTimeout(30000);
 		
 		/* These can throw either an IOException or SystemException:
 		 * - An IOException is raised when connect() encounters EOF.
@@ -193,7 +194,7 @@ namespace tut {
 		
 		try {
 			// This client takes too much time on sending the username.
-			SlowClient(50, 0).connect(socketFilename, "test", "12345");
+			SlowClient(50, 0).connect(socketAddress, "test", "12345");
 			fail("IOException or SystemException expected (1).");
 		} catch (const IOException &e) {
 			// Pass.
@@ -203,7 +204,7 @@ namespace tut {
 		
 		try {
 			// This client takes too much time on sending the password.
-			SlowClient(0, 50).connect(socketFilename, "test", "12345");
+			SlowClient(0, 50).connect(socketAddress, "test", "12345");
 			fail("IOException or SystemException expected (2).");
 		} catch (const IOException &e) {
 			// Pass.
@@ -214,7 +215,7 @@ namespace tut {
 		try {
 			// This client is fast enough at sending the username and
 			// password individually, but the combined time is too long.
-			SlowClient(25, 25).connect(socketFilename, "test", "12345");
+			SlowClient(25, 25).connect(socketAddress, "test", "12345");
 			fail("IOException or SystemException expected (3).");
 		} catch (const IOException &e) {
 			// Pass.
@@ -229,7 +230,7 @@ namespace tut {
 		memset(username, 'x', sizeof(username));
 		username[sizeof(username) - 1] = '\0';
 		try {
-			Client().connect(socketFilename, username, "1234");
+			MessageClient().connect(socketAddress, username, "1234");
 			fail("SecurityException expected");
 		} catch (const SecurityException &e) {
 			// Pass.
@@ -242,7 +243,7 @@ namespace tut {
 		memset(password, 'x', sizeof(password));
 		password[sizeof(password) - 1] = '\0';
 		try {
-			Client().connect(socketFilename, "test", password);
+			MessageClient().connect(socketAddress, "test", password);
 			fail("SecurityException expected");
 		} catch (const SecurityException &e) {
 			// Pass.
@@ -255,8 +256,8 @@ namespace tut {
 		LoggingHandlerPtr handler2(new LoggingHandler());
 		server->addHandler(handler1);
 		server->addHandler(handler2);
-		Client().connect(socketFilename, "test", "12345");
-		Client().connect(socketFilename, "test", "12345");
+		MessageClient().connect(socketAddress, "test", "12345");
+		MessageClient().connect(socketAddress, "test", "12345");
 		
 		usleep(10000); // Give the threads some time to do work.
 		ensure_equals(handler1->clientsAccepted, 2);
@@ -275,12 +276,12 @@ namespace tut {
 		handler1->returnValue = false;
 		
 		CustomClient c1, c2;
-		c1.connect(socketFilename, "test", "12345");
+		c1.connect(socketAddress, "test", "12345");
 		c1.sendText("hello");
 		c1.sendText(" ");
 		usleep(10000); // Give the thread some time to do work.
 		
-		c2.connect(socketFilename, "test", "12345");
+		c2.connect(socketAddress, "test", "12345");
 		c2.sendText("world");
 		usleep(10000); // Give the thread some time to do work.
 		
@@ -298,7 +299,7 @@ namespace tut {
 		server->addHandler(handler2);
 		
 		CustomClient c;
-		c.connect(socketFilename, "test", "12345");
+		c.connect(socketAddress, "test", "12345");
 		c.sendText("hi");
 		usleep(10000); // Give the thread some time to do work.
 		
@@ -314,7 +315,7 @@ namespace tut {
 		server->addHandler(handler2);
 		
 		CustomClient c;
-		c.connect(socketFilename, "test", "12345");
+		c.connect(socketAddress, "test", "12345");
 		c.sendText("hi");
 		usleep(10000); // Give the thread some time to do work.
 		
@@ -342,7 +343,7 @@ namespace tut {
 		
 		handler1->id = 100;
 		handler2->id = 101;
-		c1.connect(socketFilename, "test", "12345");
+		c1.connect(socketAddress, "test", "12345");
 		c1.sendText("hi");
 		usleep(10000); // Give the thread some time to do work.
 		ensure_equals(handler1->latestContext->id, 100);
@@ -350,7 +351,7 @@ namespace tut {
 		
 		handler1->id = 200;
 		handler2->id = 201;
-		c2.connect(socketFilename, "test", "12345");
+		c2.connect(socketAddress, "test", "12345");
 		c2.sendText("hi");
 		usleep(10000); // Give the thread some time to do work.
 		ensure_equals(handler1->latestContext->id, 200);
@@ -370,13 +371,13 @@ namespace tut {
 		server->addHandler(handler2);
 		{
 			{
-				Client().connect(socketFilename, "test", "12345");
+				MessageClient().connect(socketAddress, "test", "12345");
 			}
 			usleep(10000); // Give the threads some time to do work.
 			ensure_equals(handler1->clientsDisconnected, 1);
 			ensure_equals(handler2->clientsDisconnected, 1);
 			
-			Client().connect(socketFilename, "test", "12345");
+			MessageClient().connect(socketAddress, "test", "12345");
 		}
 		usleep(10000); // Give the threads some time to do work.
 		ensure_equals(handler1->clientsDisconnected, 2);

data/test/cxx/RequestHandlerTest.cpp

@@ -0,0 +1,777 @@
+#include <TestSupport.h>
+#include <agents/HelperAgent/RequestHandler.h>
+#include <agents/HelperAgent/RequestHandler.cpp>
+#include <agents/HelperAgent/AgentOptions.h>
+#include <ApplicationPool2/Pool.h>
+#include <Utils/IOUtils.h>
+#include <Utils/Timer.h>
+
+#include <boost/shared_array.hpp>
+#include <string>
+#include <vector>
+#include <map>
+#include <sstream>
+#include <cstdarg>
+#include <sys/socket.h>
+
+using namespace std;
+using namespace boost;
+using namespace Passenger;
+using namespace Passenger::ApplicationPool2;
+
+namespace tut {
+	struct RequestHandlerTest {
+		ServerInstanceDirPtr serverInstanceDir;
+		ServerInstanceDir::GenerationPtr generation;
+		string serverFilename;
+		FileDescriptor requestSocket;
+		AgentOptions agentOptions;
+
+		BackgroundEventLoop bg;
+		SpawnerFactoryPtr spawnerFactory;
+		PoolPtr pool;
+		shared_ptr<RequestHandler> handler;
+		FileDescriptor connection;
+		map<string, string> defaultHeaders;
+
+		string root;
+		string rackAppPath, wsgiAppPath;
+		
+		RequestHandlerTest() {
+			createServerInstanceDirAndGeneration(serverInstanceDir, generation);
+			spawnerFactory = make_shared<SpawnerFactory>(bg.safe, *resourceLocator, generation);
+			pool = make_shared<Pool>(bg.safe.get(), spawnerFactory);
+			serverFilename = generation->getPath() + "/server";
+			requestSocket = createUnixServer(serverFilename);
+			setNonBlocking(requestSocket);
+
+			agentOptions.passengerRoot = resourceLocator->getRoot();
+			root = resourceLocator->getRoot();
+			rackAppPath = root + "/test/stub/rack";
+			wsgiAppPath = root + "/test/stub/wsgi";
+			defaultHeaders["PASSENGER_LOAD_SHELL_ENVVARS"] = "false";
+			defaultHeaders["PASSENGER_APP_TYPE"] = "wsgi";
+			defaultHeaders["PASSENGER_SPAWN_METHOD"] = "direct";
+			defaultHeaders["REQUEST_METHOD"] = "GET";
+		}
+		
+		~RequestHandlerTest() {
+			setLogLevel(0);
+			unlink(serverFilename.c_str());
+			handler.reset();
+			pool->destroy();
+			pool.reset();
+		}
+
+		void init() {
+			handler = make_shared<RequestHandler>(bg.safe, requestSocket, pool, agentOptions);
+			bg.start();
+		}
+
+		FileDescriptor &connect() {
+			connection = connectToUnixServer(serverFilename);
+			return connection;
+		}
+
+		void sendHeaders(const map<string, string> &headers, ...) {
+			va_list ap;
+			const char *arg;
+			map<string, string>::const_iterator it;
+			vector<StaticString> args;
+
+			for (it = headers.begin(); it != headers.end(); it++) {
+				args.push_back(StaticString(it->first.data(), it->first.size() + 1));
+				args.push_back(StaticString(it->second.data(), it->second.size() + 1));
+			}
+
+			va_start(ap, headers);
+			while ((arg = va_arg(ap, const char *)) != NULL) {
+				args.push_back(StaticString(arg, strlen(arg) + 1));
+			}
+			va_end(ap);
+
+			shared_array<StaticString> args_array(new StaticString[args.size() + 2]);
+			unsigned int totalSize = 0;
+			for (unsigned int i = 0; i < args.size(); i++) {
+				args_array[i + 1] = args[i];
+				totalSize += args[i].size();
+			}
+			char totalSizeString[10];
+			snprintf(totalSizeString, sizeof(totalSizeString), "%u:", totalSize);
+			args_array[0] = StaticString(totalSizeString);
+			args_array[args.size() + 1] = ",";
+			
+			gatheredWrite(connection, args_array.get(), args.size() + 2, NULL);
+		}
+
+		string stripHeaders(const string &str) {
+			string::size_type pos = str.find("\r\n\r\n");
+			if (pos == string::npos) {
+				return str;
+			} else {
+				string result = str;
+				result.erase(0, pos + 4);
+				return result;
+			}
+		}
+
+		string inspect() {
+			string result;
+			bg.safe->runSync(boost::bind(&RequestHandlerTest::real_inspect, this, &result));
+			return result;
+		}
+
+		void real_inspect(string *result) {
+			stringstream stream;
+			handler->inspect(stream);
+			*result = stream.str();
+		}
+
+		static void writeBody(FileDescriptor conn, string body) {
+			try {
+				writeExact(conn, body);
+			} catch (const SystemException &e) {
+				if (e.code() == EPIPE) {
+					// Ignore.
+				} else {
+					throw;
+				}
+			}
+		}
+	};
+
+	DEFINE_TEST_GROUP(RequestHandlerTest);
+
+	TEST_METHOD(1) {
+		// Test one normal request.
+		init();
+		connect();
+		sendHeaders(defaultHeaders,
+			"PASSENGER_APP_ROOT", wsgiAppPath.c_str(),
+			"PATH_INFO", "/",
+			NULL);
+		string response = readAll(connection);
+		string body = stripHeaders(response);
+		ensure("Status line is correct", containsSubstring(response, "HTTP/1.1 200 OK\r\n"));
+		ensure("Headers are correct", containsSubstring(response, "Content-Type: text/html\r\n"));
+		ensure("Contains a Status header", containsSubstring(response, "Status: 200 OK\r\n"));
+		ensure_equals(body, "hello <b>world</b>");
+	}
+
+	TEST_METHOD(2) {
+		// Test multiple normal requests.
+		init();
+		for (int i = 0; i < 10; i++) {
+			connect();
+			sendHeaders(defaultHeaders,
+				"PASSENGER_APP_ROOT", wsgiAppPath.c_str(),
+				"PATH_INFO", "/",
+				NULL);
+			string response = readAll(connection);
+			string body = stripHeaders(response);
+			ensure("Status line is correct", containsSubstring(response, "HTTP/1.1 200 OK\r\n"));
+			ensure("Headers are correct", containsSubstring(response, "Content-Type: text/html\r\n"));
+			ensure("Contains a Status header", containsSubstring(response, "Status: 200 OK\r\n"));
+			ensure_equals(body, "hello <b>world</b>");
+		}
+	}
+
+	TEST_METHOD(3) {
+		// Test sending request data in pieces.
+		defaultHeaders["PASSENGER_APP_ROOT"] = wsgiAppPath;
+		defaultHeaders["PATH_INFO"] = "/";
+
+		string request;
+		map<string, string>::const_iterator it, end = defaultHeaders.end();
+		for (it = defaultHeaders.begin(); it != end; it++) {
+			request.append(it->first);
+			request.append(1, '\0');
+			request.append(it->second);
+			request.append(1, '\0');
+		}
+		request = toString(request.size()) + ":" + request;
+		request.append(",");
+
+		init();
+		connect();
+		string::size_type i = 0;
+		while (i < request.size()) {
+			const string piece = const_cast<const string &>(request).substr(i, 5);
+			writeExact(connection, piece);
+			usleep(10000);
+			i += piece.size();
+		}
+
+		string response = readAll(connection);
+		string body = stripHeaders(response);
+		ensure("Status line is correct", containsSubstring(response, "HTTP/1.1 200 OK\r\n"));
+		ensure("Headers are correct", containsSubstring(response, "Content-Type: text/html\r\n"));
+		ensure("Contains a Status header", containsSubstring(response, "Status: 200 OK\r\n"));
+		ensure_equals(body, "hello <b>world</b>");
+	}
+
+	TEST_METHOD(4) {
+		// It denies access if the connect password is wrong.
+		agentOptions.requestSocketPassword = "hello world";
+		setLogLevel(-1);
+		init();
+
+		connect();
+		writeExact(connection, "hello world");
+		sendHeaders(defaultHeaders,
+			"PASSENGER_APP_ROOT", wsgiAppPath.c_str(),
+			"PATH_INFO", "/",
+			NULL
+		);
+		ensure(containsSubstring(readAll(connection), "hello <b>world</b>"));
+
+		connect();
+		try {
+			sendHeaders(defaultHeaders,
+				"PASSENGER_APP_ROOT", wsgiAppPath.c_str(),
+				"PATH_INFO", "/",
+				NULL
+			);
+		} catch (const SystemException &e) {
+			ensure_equals(e.code(), EPIPE);
+			return;
+		}
+		string response;
+		try {
+			response = readAll(connection);
+		} catch (const SystemException &e) {
+			ensure_equals(e.code(), ECONNRESET);
+			return;
+		}
+		ensure_equals(response, "");
+	}
+
+	TEST_METHOD(5) {
+		// It disconnects us if the connect password is not sent within a certain time.
+		agentOptions.requestSocketPassword = "hello world";
+		setLogLevel(-1);
+		handler = make_shared<RequestHandler>(bg.safe, requestSocket, pool, agentOptions);
+		handler->connectPasswordTimeout = 40;
+		bg.start();
+
+		connect();
+		Timer timer;
+		readAll(connection);
+		timer.stop();
+		ensure(timer.elapsed() <= 60);
+	}
+
+	TEST_METHOD(6) {
+		// It works correct if the connect password is sent in pieces.
+		agentOptions.requestSocketPassword = "hello world";
+		init();
+		connect();
+		writeExact(connection, "hello");
+		usleep(10000);
+		writeExact(connection, " world");
+		usleep(10000);
+		sendHeaders(defaultHeaders,
+			"PASSENGER_APP_ROOT", wsgiAppPath.c_str(),
+			"PATH_INFO", "/",
+			NULL
+		);
+		ensure(containsSubstring(readAll(connection), "hello <b>world</b>"));
+	}
+
+	TEST_METHOD(7) {
+		// It closes the connection with the application if the client has closed the connection.
+		init();
+		connect();
+		sendHeaders(defaultHeaders,
+			"PASSENGER_APP_ROOT", wsgiAppPath.c_str(),
+			"PATH_INFO", "/stream",
+			NULL
+		);
+		BufferedIO io(connection);
+		ensure_equals(io.readLine(), "HTTP/1.1 200 OK\r\n");
+		ensure_equals(pool->getProcessCount(), 1u);
+		SuperGroupPtr superGroup = pool->superGroups.get(wsgiAppPath);
+		ProcessPtr process = superGroup->defaultGroup->processes.front();
+		ensure_equals(process->sessions, 1);
+		connection.close();
+		EVENTUALLY(5,
+			result = process->sessions == 0;
+		);
+	}
+	
+	TEST_METHOD(10) {
+		// If the app crashes at startup without an error page then it renders
+		// a generic error page.
+		TempDir tempdir("tmp.handler");
+		writeFile("tmp.handler/start.rb",
+			"STDERR.puts 'I have failed'");
+
+		setLogLevel(-2);
+		spawnerFactory->forwardStderr = false;
+		init();
+		connect();
+		sendHeaders(defaultHeaders,
+			"PASSENGER_APP_ROOT", (root + "/test/tmp.handler").c_str(),
+			"PASSENGER_APP_TYPE", "",
+			"PASSENGER_START_COMMAND", ("ruby\1" + root + "/test/tmp.handler/start.rb").c_str(),
+			"PATH_INFO", "/",
+			NULL);
+		string response = readAll(connection);
+		ensure(containsSubstring(response, "HTTP/1.1 500 Internal Server Error\r\n"));
+		ensure(containsSubstring(response, "Status: 500 Internal Server Error\r\n"));
+		ensure(containsSubstring(response, "I have failed"));
+	}
+
+	TEST_METHOD(11) {
+		// If the app crashes at startup with an error page then it renders
+		// a friendly error page.
+		TempDir tempdir("tmp.handler");
+		writeFile("tmp.handler/start.rb",
+			"STDERR.puts 'Error'\n"
+			"STDERR.puts\n"
+			"STDERR.puts 'I have failed'\n");
+
+		setLogLevel(-2);
+		spawnerFactory->forwardStderr = false;
+		init();
+		connect();
+		sendHeaders(defaultHeaders,
+			"PASSENGER_APP_ROOT", (root + "/test/tmp.handler").c_str(),
+			"PASSENGER_APP_TYPE", "",
+			"PASSENGER_START_COMMAND", ("ruby\1" + root + "/test/tmp.handler/start.rb").c_str(),
+			"PATH_INFO", "/",
+			NULL);
+		string response = readAll(connection);
+		ensure(containsSubstring(response, "HTTP/1.1 500 Internal Server Error\r\n"));
+		ensure(containsSubstring(response, "Status: 500 Internal Server Error\r\n"));
+		ensure(containsSubstring(response, "Content-Type: text/html; charset=UTF-8\r\n"));
+		ensure(containsSubstring(response, "<html>"));
+		ensure(containsSubstring(response, "I have failed"));
+	}
+
+	TEST_METHOD(12) {
+		// If spawning fails because of an internal error then it reports the error appropriately.
+		TempDir tempdir("tmp.handler");
+		writeFile("tmp.handler/start.rb", "");
+
+		setLogLevel(-2);
+		spawnerFactory->forwardStderr = false;
+		init();
+		connect();
+		sendHeaders(defaultHeaders,
+			"PASSENGER_APP_ROOT", (root + "/test/tmp.handler").c_str(),
+			"PASSENGER_APP_TYPE", "",
+			"PASSENGER_START_COMMAND", ("ruby\1" + root + "/test/tmp.handler/start.rb").c_str(),
+			"PASSENGER_RAISE_INTERNAL_ERROR", "true",
+			"PATH_INFO", "/",
+			NULL);
+		string response = readAll(connection);
+		ensure(containsSubstring(response, "HTTP/1.1 500 Internal Server Error\r\n"));
+		ensure(containsSubstring(response, "Status: 500 Internal Server Error\r\n"));
+		ensure(containsSubstring(response, "Content-Type: text/html; charset=UTF-8\r\n"));
+		ensure(containsSubstring(response, "<html>"));
+		ensure(containsSubstring(response, "An internal error occurred while trying to spawn the application."));
+		ensure(containsSubstring(response, "Passenger:<wbr>:<wbr>RuntimeException"));
+		ensure(containsSubstring(response, "An internal error!"));
+		ensure(containsSubstring(response, "Spawner.h"));
+	}
+
+	TEST_METHOD(13) {
+		// Error pages respect the PASSENGER_STATUS_LINE option.
+		TempDir tempdir("tmp.handler");
+		writeFile("tmp.handler/start.rb",
+			"STDERR.puts 'I have failed'");
+
+		setLogLevel(-2);
+		spawnerFactory->forwardStderr = false;
+		init();
+		connect();
+		sendHeaders(defaultHeaders,
+			"PASSENGER_APP_ROOT", (root + "/test/tmp.handler").c_str(),
+			"PASSENGER_APP_TYPE", "",
+			"PASSENGER_START_COMMAND", ("ruby\1" + root + "/test/tmp.handler/start.rb").c_str(),
+			"PASSENGER_STATUS_LINE", "false",
+			"PATH_INFO", "/",
+			NULL);
+		string response = readAll(connection);
+		ensure(!containsSubstring(response, "HTTP/1.1 "));
+		ensure(containsSubstring(response, "Status: 500 Internal Server Error\r\n"));
+		ensure(containsSubstring(response, "I have failed"));
+	}
+
+	TEST_METHOD(14) {
+		// If PASSENGER_FRIENDLY_ERROR_PAGES is false then it does not render
+		// a friendly error page.
+		TempDir tempdir("tmp.handler");
+		writeFile("tmp.handler/start.rb",
+			"STDERR.puts 'Error'\n"
+			"STDERR.puts\n"
+			"STDERR.puts 'I have failed'\n");
+
+		setLogLevel(-2);
+		spawnerFactory->forwardStderr = false;
+		init();
+		connect();
+		sendHeaders(defaultHeaders,
+			"PASSENGER_APP_ROOT", (root + "/test/tmp.handler").c_str(),
+			"PASSENGER_APP_TYPE", "",
+			"PASSENGER_START_COMMAND", ("ruby\1" + root + "/test/tmp.handler/start.rb").c_str(),
+			"PASSENGER_FRIENDLY_ERROR_PAGES", "false",
+			"PATH_INFO", "/",
+			NULL);
+		string response = readAll(connection);
+		ensure(containsSubstring(response, "HTTP/1.1 500 Internal Server Error\r\n"));
+		ensure(containsSubstring(response, "Status: 500 Internal Server Error\r\n"));
+		ensure(containsSubstring(response, "Content-Type: text/html; charset=UTF-8\r\n"));
+		ensure(containsSubstring(response, "<html>"));
+		ensure(!containsSubstring(response, "I have failed"));
+		ensure(containsSubstring(response, "We're sorry, but something went wrong"));
+	}
+
+	TEST_METHOD(20) {
+		// It streams the request body to the application.
+		DeleteFileEventually file("tmp.output");
+
+		init();
+		connect();
+		sendHeaders(defaultHeaders,
+			"PASSENGER_APP_ROOT", wsgiAppPath.c_str(),
+			"PATH_INFO", "/upload",
+			"HTTP_X_OUTPUT", (root + "/test/tmp.output").c_str(),
+			NULL);
+		writeExact(connection, "hello\n");
+		EVENTUALLY(5,
+			result = fileExists("tmp.output") && readAll("tmp.output") == "hello\n";
+		);
+		writeExact(connection, "world\n");
+		EVENTUALLY(3,
+			result = readAll("tmp.output") == "hello\nworld\n";
+		);
+		shutdown(connection, SHUT_WR);
+		ensure_equals(stripHeaders(readAll(connection)), "ok");
+	}
+
+	TEST_METHOD(21) {
+		// It buffers the request body if PASSENGER_BUFFERING is true.
+		DeleteFileEventually file("tmp.output");
+
+		init();
+		connect();
+		sendHeaders(defaultHeaders,
+			"PASSENGER_APP_ROOT", wsgiAppPath.c_str(),
+			"PASSENGER_BUFFERING", "true",
+			"PATH_INFO", "/upload",
+			"HTTP_X_OUTPUT", (root + "/test/tmp.output").c_str(),
+			NULL);
+		writeExact(connection, "hello\n");
+		SHOULD_NEVER_HAPPEN(200,
+			result = fileExists("tmp.output");
+		);
+		writeExact(connection, "world\n");
+		SHOULD_NEVER_HAPPEN(200,
+			result = fileExists("tmp.output");
+		);
+		shutdown(connection, SHUT_WR);
+		ensure_equals(stripHeaders(readAll(connection)), "ok");
+	}
+
+	TEST_METHOD(22) {
+		set_test_name("Test buffering of large request bodies that fit in neither the socket "
+		              "buffer nor the FileBackedPipe memory buffer, and that the application "
+		              "cannot read quickly enough.");
+
+		DeleteFileEventually d1("/tmp/wait.txt");
+		DeleteFileEventually d2("/tmp/output.txt");
+
+		// 2.6 MB of request body. Guaranteed not to fit in any socket buffer.
+		string requestBody;
+		for (int i = 0; i < 204800; i++) {
+			requestBody.append("hello world!\n");
+		}
+
+		init();
+		connect();
+		sendHeaders(defaultHeaders,
+			"PASSENGER_APP_ROOT", wsgiAppPath.c_str(),
+			"PATH_INFO", "/upload",
+			"PASSENGER_BUFFERING", "true",
+			"HTTP_X_WAIT_FOR_FILE", "/tmp/wait.txt",
+			"HTTP_X_OUTPUT", "/tmp/output.txt",
+			NULL);
+		
+		// Should not block.
+		writeExact(connection, requestBody);
+		shutdown(connection, SHUT_WR);
+		
+		EVENTUALLY(5,
+			result = containsSubstring(inspect(), "session initiated           = true");
+		);
+		touchFile("/tmp/wait.txt");
+
+		string result = stripHeaders(readAll(connection));
+		ensure_equals(result, "ok");
+		struct stat buf;
+		ensure(stat("/tmp/output.txt", &buf) == 0);
+		ensure_equals(buf.st_size, (off_t) requestBody.size());
+	}
+
+	TEST_METHOD(30) {
+		// It replaces HTTP_CONTENT_LENGTH with CONTENT_LENGTH.
+		init();
+		connect();
+		sendHeaders(defaultHeaders,
+			"PASSENGER_APP_ROOT", wsgiAppPath.c_str(),
+			"PATH_INFO", "/env",
+			"HTTP_CONTENT_LENGTH", "5",
+			NULL);
+		writeExact(connection, "hello");
+		string response = readAll(connection);
+		ensure(containsSubstring(response, "CONTENT_LENGTH = 5\n"));
+		ensure(!containsSubstring(response, "HTTP_CONTENT_LENGTH"));
+	}
+	
+	TEST_METHOD(31) {
+		// It replaces HTTP_CONTENT_TYPE with CONTENT_TYPE.
+		init();
+		connect();
+		sendHeaders(defaultHeaders,
+			"PASSENGER_APP_ROOT", wsgiAppPath.c_str(),
+			"PATH_INFO", "/env",
+			"HTTP_CONTENT_TYPE", "application/json",
+			NULL);
+		string response = readAll(connection);
+		ensure(containsSubstring(response, "CONTENT_TYPE = application/json\n"));
+		ensure(!containsSubstring(response, "HTTP_CONTENT_TYPE"));
+	}
+
+	TEST_METHOD(35) {
+		// The response doesn't contain an HTTP status line if PASSENGER_STATUS_LINE is false.
+		init();
+		connect();
+		sendHeaders(defaultHeaders,
+			"PASSENGER_APP_ROOT", wsgiAppPath.c_str(),
+			"PASSENGER_STATUS_LINE", "false",
+			"PATH_INFO", "/",
+			NULL);
+		string response = readAll(connection);
+		ensure(!containsSubstring(response, "HTTP/1.1 "));
+		ensure(containsSubstring(response, "Status: 200 OK\r\n"));
+	}
+
+	TEST_METHOD(36) {
+		// If the application outputs a status line without a reason phrase,
+		// then a reason phrase is automatically appended.
+		init();
+		connect();
+		sendHeaders(defaultHeaders,
+			"PASSENGER_APP_ROOT", wsgiAppPath.c_str(),
+			"PATH_INFO", "/custom_status",
+			"HTTP_X_CUSTOM_STATUS", "201",
+			NULL);
+		string response = readAll(connection);
+		ensure(containsSubstring(response, "HTTP/1.1 201 Created\r\n"));
+		ensure(containsSubstring(response, "Status: 201 Created\r\n"));
+	}
+
+	TEST_METHOD(37) {
+		// If the application outputs a status line with a custom reason phrase,
+		// then that reason phrase is used.
+		init();
+		connect();
+		sendHeaders(defaultHeaders,
+			"PASSENGER_APP_ROOT", wsgiAppPath.c_str(),
+			"PATH_INFO", "/custom_status",
+			"HTTP_X_CUSTOM_STATUS", "201 Bunnies Jump",
+			NULL);
+		string response = readAll(connection);
+		ensure(containsSubstring(response, "HTTP/1.1 201 Bunnies Jump\r\n"));
+		ensure(containsSubstring(response, "Status: 201 Bunnies Jump\r\n"));
+	}
+	
+	TEST_METHOD(38) {
+		// If the application doesn't output a status line then it rejects the application response.
+		// TODO
+	}
+
+	TEST_METHOD(39) {
+		// Test handling of slow clients that can't receive response data fast enough (response buffering).
+		init();
+		connect();
+		sendHeaders(defaultHeaders,
+			"PASSENGER_APP_ROOT", wsgiAppPath.c_str(),
+			"PATH_INFO", "/blob",
+			"HTTP_X_SIZE", "10485760",
+			NULL);
+		EVENTUALLY(10,
+			result = containsSubstring(inspect(), "appInput reachedEnd         = true");
+		);
+		string result = stripHeaders(readAll(connection));
+		ensure_equals(result.size(), 10485760u);
+		const char *data = result.data();
+		const char *end  = result.data() + result.size();
+		while (data < end) {
+			ensure_equals(*data, 'x');
+			data++;
+		}
+	}
+
+	TEST_METHOD(40) {
+		set_test_name("Test that RequestHandler does not read more than CONTENT_LENGTH bytes "
+		              "from the client body (when buffering is on and request body is large).");
+
+		DeleteFileEventually d("/tmp/output.txt");
+
+		// 2.6 MB of request body. Guaranteed not to fit in any socket buffer.
+		string requestBody;
+		for (int i = 0; i < 204800; i++) {
+			requestBody.append("hello world!\n");
+		}
+
+		init();
+		connect();
+		sendHeaders(defaultHeaders,
+			"PASSENGER_APP_ROOT", wsgiAppPath.c_str(),
+			"PATH_INFO", "/upload",
+			"CONTENT_LENGTH", toString(requestBody.size()).c_str(),
+			"PASSENGER_BUFFERING", "true",
+			"HTTP_X_OUTPUT", "/tmp/output.txt",
+			NULL);
+		writeExact(connection, requestBody);
+
+		string result = stripHeaders(readAll(connection));
+		ensure_equals(result, "ok");
+		struct stat buf;
+		ensure(stat("/tmp/output.txt", &buf) == 0);
+		ensure_equals(buf.st_size, (off_t) requestBody.size());
+	}
+
+	TEST_METHOD(41) {
+		set_test_name("Test that RequestHandler does not read more than CONTENT_LENGTH bytes "
+		              "from the client body (when buffering is on and request body is small).");
+
+		DeleteFileEventually d("/tmp/output.txt");
+		string requestBody = "hello world";
+
+		init();
+		connect();
+		sendHeaders(defaultHeaders,
+			"PASSENGER_APP_ROOT", wsgiAppPath.c_str(),
+			"PATH_INFO", "/upload",
+			"CONTENT_LENGTH", toString(requestBody.size()).c_str(),
+			"PASSENGER_BUFFERING", "true",
+			"HTTP_X_OUTPUT", "/tmp/output.txt",
+			NULL);
+		writeExact(connection, requestBody);
+
+		string result = stripHeaders(readAll(connection));
+		ensure_equals(result, "ok");
+		struct stat buf;
+		ensure(stat("/tmp/output.txt", &buf) == 0);
+		ensure_equals(buf.st_size, (off_t) requestBody.size());
+	}
+
+	TEST_METHOD(42) {
+		set_test_name("Test that RequestHandler does not read more than CONTENT_LENGTH bytes "
+		              "from the client body (when buffering is off and request body is large).");
+
+		DeleteFileEventually d("/tmp/output.txt");
+
+		// 2 MB of request body. Guaranteed not to fit in any socket buffer.
+		string requestBody;
+		for (int i = 0; i < 102400; i++) {
+			char buf[100];
+			snprintf(buf, sizeof(buf), "%06d: hello world!\n", i);
+			requestBody.append(buf);
+		}
+
+		init();
+		connect();
+		sendHeaders(defaultHeaders,
+			"PASSENGER_APP_ROOT", wsgiAppPath.c_str(),
+			"PATH_INFO", "/upload",
+			"CONTENT_LENGTH", toString(requestBody.size()).c_str(),
+			"HTTP_X_OUTPUT", "/tmp/output.txt",
+			NULL);
+
+		TempThread thr(boost::bind(RequestHandlerTest::writeBody, connection, requestBody));
+
+		string result = stripHeaders(readAll(connection));
+		ensure_equals(result, "ok");
+		struct stat buf;
+		ensure(stat("/tmp/output.txt", &buf) == 0);
+		ensure_equals(buf.st_size, (off_t) requestBody.size());
+	}
+
+	TEST_METHOD(43) {
+		set_test_name("Test that RequestHandler does not read more than CONTENT_LENGTH bytes "
+		              "from the client body (when buffering is off and request body is small).");
+
+		DeleteFileEventually d("/tmp/output.txt");
+		string requestBody = "hello world";
+
+		init();
+		connect();
+		sendHeaders(defaultHeaders,
+			"PASSENGER_APP_ROOT", wsgiAppPath.c_str(),
+			"PATH_INFO", "/upload",
+			"CONTENT_LENGTH", toString(requestBody.size()).c_str(),
+			"HTTP_X_OUTPUT", "/tmp/output.txt",
+			NULL);
+
+		TempThread thr(boost::bind(RequestHandlerTest::writeBody, connection, requestBody));
+
+		string result = stripHeaders(readAll(connection));
+		ensure_equals(result, "ok");
+		struct stat buf;
+		ensure(stat("/tmp/output.txt", &buf) == 0);
+		ensure_equals(buf.st_size, (off_t) requestBody.size());
+	}
+
+	TEST_METHOD(44) {
+		set_test_name("Test that RequestHandler does not pass any client body data when CONTENT_LENGTH == 0 (when buffering is on).");
+
+		DeleteFileEventually d("/tmp/output.txt");
+
+		init();
+		connect();
+		sendHeaders(defaultHeaders,
+			"PASSENGER_APP_ROOT", wsgiAppPath.c_str(),
+			"PATH_INFO", "/upload",
+			"CONTENT_LENGTH", "0",
+			"PASSENGER_BUFFERING", "true",
+			"HTTP_X_OUTPUT", "/tmp/output.txt",
+			NULL);
+		writeExact(connection, "hello world");
+
+		string result = stripHeaders(readAll(connection));
+		ensure_equals(result, "ok");
+		struct stat buf;
+		ensure(stat("/tmp/output.txt", &buf) == 0);
+		ensure_equals(buf.st_size, (off_t) 0);
+	}
+
+	TEST_METHOD(45) {
+		set_test_name("Test that RequestHandler does not pass any client body data when CONTENT_LENGTH == 0 (when buffering is off).");
+
+		DeleteFileEventually d("/tmp/output.txt");
+
+		init();
+		connect();
+		sendHeaders(defaultHeaders,
+			"PASSENGER_APP_ROOT", wsgiAppPath.c_str(),
+			"PATH_INFO", "/upload",
+			"CONTENT_LENGTH", "0",
+			"HTTP_X_OUTPUT", "/tmp/output.txt",
+			NULL);
+		writeExact(connection, "hello world");
+
+		string result = stripHeaders(readAll(connection));
+		ensure_equals(result, "ok");
+		struct stat buf;
+		ensure(stat("/tmp/output.txt", &buf) == 0);
+		ensure_equals(buf.st_size, (off_t) 0);
+	}
+
+	// Test small response buffering.
+	// Test large response buffering.
+}