passenger 4.0.60 → 5.0.0.beta1

data/ext/common/agents/HelperAgent/OptionParser.h

@@ -0,0 +1,311 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2010-2014 Phusion
+ *
+ *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in
+ *  all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ *  THE SOFTWARE.
+ */
+#ifndef _PASSENGER_SERVER_OPTION_PARSER_H_
+#define _PASSENGER_SERVER_OPTION_PARSER_H_
+
+#include <boost/thread.hpp>
+#include <cstdio>
+#include <cstdlib>
+#include <Constants.h>
+#include <Utils.h>
+#include <Utils/VariantMap.h>
+#include <Utils/OptionParsing.h>
+#include <Utils/StrIntUtils.h>
+
+namespace Passenger {
+
+using namespace std;
+
+
+inline void
+serverUsage() {
+	printf("Usage: " AGENT_EXE " server <OPTIONS...> [APP DIRECTORY]\n");
+	printf("Runs the " PROGRAM_NAME " standalone HTTP server agent.\n");
+	printf("\n");
+	printf("The server starts in single-app mode, unless --multi-app is specified. When\n");
+	printf("in single-app mode, it serves the app at the current working directory, or the\n");
+	printf("app specified by APP DIRECTORY.\n");
+	printf("\n");
+	printf("Required options:\n");
+	printf("      --passenger-root PATH  The location to the " PROGRAM_NAME " source\n");
+	printf("                             directory\n");
+	printf("\n");
+	printf("Socket options (optional):\n");
+	printf("  -l, --listen ADDRESS      Listen on the given address. The address must be\n");
+	printf("                            formatted as tcp://IP:PORT for TCP sockets, or\n");
+	printf("                            unix:PATH for Unix domain sockets. You can specify\n");
+	printf("                            this option multiple times (up to %u times) to\n",
+		SERVER_KIT_MAX_SERVER_ENDPOINTS);
+	printf("                            listen on multiple addresses. Default:\n");
+	printf("                            " DEFAULT_HTTP_SERVER_LISTEN_ADDRESS "\n");
+	printf("      --admin-listen ADDRESS\n");
+	printf("                            Listen on the given address for admin commands.\n");
+	printf("                            The same syntax and limitations as with --listen\n");
+	printf("                            are applicable\n");
+	printf("\n");
+	printf("Daemon options (optional):\n");
+	printf("      --pid-file PATH       Store the server's PID in the given file. The file\n");
+	printf("                            is deleted on exit\n");
+	printf("\n");
+	printf("Security options (optional):\n");
+	printf("      --multi-app-password-file PATH\n");
+	printf("                            Password-protect access to the HTTP server\n");
+	printf("                            (multi-app mode only)\n");
+	printf("      --authorize [LEVEL]:USERNAME:PASSWORDFILE\n");
+	printf("                            Enables authentication on the admin server, through\n");
+	printf("                            the given admin account. LEVEL indicates the\n");
+	printf("                            privilege level (see below). PASSWORDFILE must\n");
+	printf("                            point to a file containing the password\n");
+	printf("\n");
+	printf("Application serving options (optional):\n");
+	printf("  -e, --environment NAME    Default framework environment name to use.\n");
+	printf("                            Default: " DEFAULT_APP_ENV "\n");
+	printf("      --app-type TYPE       The type of application you want to serve\n");
+	printf("                            (single-app mode only)\n");
+	printf("      --startup-file PATH   The path of the app's startup file, relative to\n");
+	printf("                            the app root directory (single-app mode only)\n");
+	printf("      --spawn-method NAME   Spawn method to use. Can either be 'smart' or\n");
+	printf("                            'direct'. Default: %s\n", DEFAULT_SPAWN_METHOD);
+	printf("      --load-shell-envvars  Load shell startup files before loading application\n");
+	printf("      --concurrency-model   The concurrency model to use for the app, either\n");
+	printf("                            'process' or 'thread' (Enterprise only).\n");
+	printf("                            Default: " DEFAULT_CONCURRENCY_MODEL "\n");
+	printf("      --app-thread-count    The number of application threads to use when using\n");
+	printf("                            the 'thread' concurrency model (Enterprise only).\n");
+	printf("                            Default: %d\n", DEFAULT_APP_THREAD_COUNT);
+	printf("\n");
+	printf("      --multi-app           Enable multi-app mode\n");
+	printf("\n");
+	printf("      --force-friendly-error-pages\n");
+	printf("                            Force friendly error pages to be always on\n");
+	printf("      --disable-friendly-error-pages\n");
+	printf("                            Force friendly error pages to be always off\n");
+	printf("      --disable-turbocaching\n");
+	printf("                            Disable turbocaching\n");
+	printf("\n");
+	printf("      --ruby PATH           Default Ruby interpreter to use.\n");
+	printf("\n");
+	printf("      --rolling-restarts    Enable rolling restarts (Enterprise only)\n");
+	printf("\n");
+	printf("Process management options (optional):\n");
+	printf("      --max-pool-size N     Maximum number of application processes.\n");
+	printf("                            Default: %d\n", DEFAULT_MAX_POOL_SIZE);
+	printf("      --pool-idle-time SECS\n");
+	printf("                            Maximum number of seconds an application process\n");
+	printf("                            may be idle. Default: %d\n", DEFAULT_POOL_IDLE_TIME);
+	printf("      --min-instances N     Minimum number of application processes. Default: 1\n");
+	printf("\n");
+	printf("Other options (optional):\n");
+	printf("      --log-file PATH       Log to the given file.\n");
+	printf("      --log-level LEVEL     Logging level. Default: %d\n", DEFAULT_LOG_LEVEL);
+	printf("      --stat-throttle-rate SECONDS\n");
+	printf("                            Throttle filesystem restart.txt checks to at most\n");
+	printf("                            once per given seconds. Default: %d\n", DEFAULT_STAT_THROTTLE_RATE);
+	printf("      --no-show-version-in-header\n");
+	printf("                            Do not show " PROGRAM_NAME " version number in\n");
+	printf("                            HTTP headers.\n");
+	printf("      --data-buffer-dir PATH\n");
+	printf("                            Directory to store data buffers in. Default:\n");
+	printf("                            %s\n", getSystemTempDir());
+	printf("      --no-graceful-exit    When exiting, exit immediately instead of waiting\n");
+	printf("                            for all connections to terminate\n");
+	printf("      --benchmark MODE      Enable benchmark mode. Available modes:\n");
+	printf("                            after_accept,before_checkout,after_checkout,\n");
+	printf("                            response_begin\n");
+	printf("      --disable-selfchecks  Disable various self-checks. This improves\n");
+	printf("                            performance, but might delay finding bugs in\n");
+	printf("                            " PROGRAM_NAME "\n");
+	printf("      --threads NUMBER      Number of threads to use for request handling.\n");
+	printf("                            Default: number of CPU cores (%d)\n",
+		boost::thread::hardware_concurrency());
+	printf("      --cpu-affine          Enable per-thread CPU affinity (Linux only)\n");
+	printf("  -h, --help                Show this help\n");
+	printf("\n");
+	printf("Admin account privilege levels (ordered from most to least privileges):\n");
+	printf("  readonly    Read-only access\n");
+	printf("  full        Full access (default)\n");
+}
+
+inline bool
+parseServerOption(int argc, const char *argv[], int &i, VariantMap &options) {
+	OptionParser p(serverUsage);
+
+	if (p.isValueFlag(argc, i, argv[i], '\0', "--passenger-root")) {
+		options.set("passenger_root", argv[i + 1]);
+		i += 2;
+	} else if (p.isValueFlag(argc, i, argv[i], 'l', "--listen")) {
+		if (getSocketAddressType(argv[i + 1]) != SAT_UNKNOWN) {
+			vector<string> addresses = options.getStrSet("server_addresses", false);
+			if (addresses.size() == SERVER_KIT_MAX_SERVER_ENDPOINTS) {
+				fprintf(stderr, "ERROR: you may specify up to %u --listen addresses.\n",
+					SERVER_KIT_MAX_SERVER_ENDPOINTS);
+				exit(1);
+			}
+			addresses.push_back(argv[i + 1]);
+			options.setStrSet("server_addresses", addresses);
+			i += 2;
+		} else {
+			fprintf(stderr, "ERROR: invalid address format for --listen. The address "
+				"must be formatted as tcp://IP:PORT for TCP sockets, or unix:PATH "
+				"for Unix domain sockets.\n");
+			exit(1);
+		}
+	} else if (p.isValueFlag(argc, i, argv[i], '\0', "--admin-listen")) {
+		if (getSocketAddressType(argv[i + 1]) != SAT_UNKNOWN) {
+			vector<string> addresses = options.getStrSet("server_admin_addresses",
+				false);
+			if (addresses.size() == SERVER_KIT_MAX_SERVER_ENDPOINTS) {
+				fprintf(stderr, "ERROR: you may specify up to %u --admin-listen addresses.\n",
+					SERVER_KIT_MAX_SERVER_ENDPOINTS);
+				exit(1);
+			}
+			addresses.push_back(argv[i + 1]);
+			options.setStrSet("server_admin_addresses", addresses);
+			i += 2;
+		} else {
+			fprintf(stderr, "ERROR: invalid address format for --admin-listen. The address "
+				"must be formatted as tcp://IP:PORT for TCP sockets, or unix:PATH "
+				"for Unix domain sockets.\n");
+			exit(1);
+		}
+	} else if (p.isValueFlag(argc, i, argv[i], '\0', "--pid-file")) {
+		options.set("server_pid_file", argv[i + 1]);
+		i += 2;
+	} else if (p.isValueFlag(argc, i, argv[i], '\0', "--authorize")) {
+		vector<string> args;
+		vector<string> authorizations = options.getStrSet("server_authorizations",
+				false);
+
+		split(argv[i + 1], ':', args);
+		if (args.size() < 2 || args.size() > 3) {
+			fprintf(stderr, "ERROR: invalid format for --authorize. The syntax "
+				"is \"[LEVEL:]USERNAME:PASSWORDFILE\".\n");
+			exit(1);
+		}
+
+		authorizations.push_back(argv[i + 1]);
+		options.setStrSet("server_authorizations", authorizations);
+		i += 2;
+	} else if (p.isValueFlag(argc, i, argv[i], '\0', "--max-pool-size")) {
+		options.setInt("max_pool_size", atoi(argv[i + 1]));
+		i += 2;
+	} else if (p.isValueFlag(argc, i, argv[i], '\0', "--pool-idle-time")) {
+		options.setInt("pool_idle_time", atoi(argv[i + 1]));
+		i += 2;
+	} else if (p.isValueFlag(argc, i, argv[i], '\0', "--min-instances")) {
+		options.setInt("min_instances", atoi(argv[i + 1]));
+		i += 2;
+	} else if (p.isValueFlag(argc, i, argv[i], 'e', "--environment")) {
+		options.set("environment", argv[i + 1]);
+		i += 2;
+	} else if (p.isValueFlag(argc, i, argv[i], '\0', "--app-type")) {
+		options.set("app_type", argv[i + 1]);
+		i += 2;
+	} else if (p.isValueFlag(argc, i, argv[i], '\0', "--startup-file")) {
+		options.set("startup_file", argv[i + 1]);
+		i += 2;
+	} else if (p.isValueFlag(argc, i, argv[i], '\0', "--spawn-method")) {
+		options.set("spawn_method", argv[i + 1]);
+		i += 2;
+	} else if (p.isFlag(argv[i], '\0', "--load-shell-envvars")) {
+		options.setBool("load_shell_envvars", true);
+		i++;
+	} else if (p.isValueFlag(argc, i, argv[i], '\0', "--concurrency-model")) {
+		options.set("concurrency_model", argv[i + 1]);
+		i += 2;
+	} else if (p.isValueFlag(argc, i, argv[i], '\0', "--app-thread-count")) {
+		options.setInt("app_thread_count", atoi(argv[i + 1]));
+		i += 2;
+	} else if (p.isFlag(argv[i], '\0', "--multi-app")) {
+		options.setBool("multi_app", true);
+		i++;
+	} else if (p.isFlag(argv[i], '\0', "--force-friendly-error-pages")) {
+		options.set("friendly_error_pages", "true");
+		i++;
+	} else if (p.isFlag(argv[i], '\0', "--disable-friendly-error-pages")) {
+		options.set("friendly_error_pages", "false");
+		i++;
+	} else if (p.isFlag(argv[i], '\0', "--disable-turbocaching")) {
+		options.setBool("turbocaching", false);
+		i++;
+	} else if (p.isValueFlag(argc, i, argv[i], '\0', "--ruby")) {
+		options.set("default_ruby", argv[i + 1]);
+		i += 2;
+	} else if (p.isFlag(argv[i], '\0', "--rolling-restarts")) {
+		options.setBool("rolling_restarts", true);
+		i++;
+	} else if (p.isValueFlag(argc, i, argv[i], '\0', "--log-level")) {
+		// We do not set log_level because, when this function is called from
+		// the Watchdog, we don't want to affect the Watchdog's own log level.
+		options.setInt("server_log_level", atoi(argv[i + 1]));
+		i += 2;
+	} else if (p.isValueFlag(argc, i, argv[i], '\0', "--log-file")) {
+		// We do not set debug_log_file because, when this function is called from
+		// the Watchdog, we don't want to affect the Watchdog's own log file.
+		options.set("server_log_file", argv[i + 1]);
+		i += 2;
+	} else if (p.isValueFlag(argc, i, argv[i], '\0', "--stat-throttle-rate")) {
+		options.setInt("stat_throttle_rate", atoi(argv[i + 1]));
+		i += 2;
+	} else if (p.isFlag(argv[i], '\0', "--no-show-version-in-header")) {
+		options.setBool("show_version_in_header", false);
+		i++;
+	} else if (p.isValueFlag(argc, i, argv[i], '\0', "--data-buffer-dir")) {
+		options.setInt("data_buffer_dir", atoi(argv[i + 1]));
+		i += 2;
+	} else if (p.isFlag(argv[i], '\0', "--no-graceful-exit")) {
+		options.setBool("server_graceful_exit", false);
+		i++;
+	} else if (p.isValueFlag(argc, i, argv[i], '\0', "--benchmark")) {
+		options.set("benchmark_mode", argv[i + 1]);
+		i += 2;
+	} else if (p.isFlag(argv[i], '\0', "--disable-selfchecks")) {
+		options.setBool("selfchecks", false);
+		i++;
+	} else if (p.isValueFlag(argc, i, argv[i], '\0', "--threads")) {
+		options.setInt("server_threads", atoi(argv[i + 1]));
+		i += 2;
+	} else if (p.isFlag(argv[i], '\0', "--cpu-affine")) {
+		options.setBool("server_cpu_affine", true);
+		i++;
+	} else if (!startsWith(argv[i], "-")) {
+		if (!options.has("app_root")) {
+			options.set("app_root", argv[i]);
+			i++;
+		} else {
+			fprintf(stderr, "ERROR: you may not pass multiple application directories. "
+				"Please type '%s server --help' for usage.\n", argv[0]);
+			exit(1);
+		}
+	} else {
+		return false;
+	}
+	return true;
+}
+
+
+} // namespace Passenger
+
+#endif /* _PASSENGER_SERVER_OPTION_PARSER_H_ */

data/ext/common/agents/HelperAgent/RequestHandler.h

@@ -109,12 +109,14 @@
 #ifndef _PASSENGER_REQUEST_HANDLER_H_
 #define _PASSENGER_REQUEST_HANDLER_H_
 
+//#define DEBUG_RH_EVENT_LOOP_BLOCKING
+
 #include <boost/shared_ptr.hpp>
-#include <boost/weak_ptr.hpp>
 #include <boost/make_shared.hpp>
-#include <boost/regex.hpp>
 #include <boost/cstdint.hpp>
+#include <oxt/macros.hpp>
 #include <ev++.h>
+#include <ostream>
 
 #if defined(__GLIBCXX__) || defined(__APPLE__)
 	#include <cxxabi.h>
@@ -122,32 +124,34 @@
 #endif
 
 #include <sys/types.h>
-#include <arpa/inet.h>
-#include <sys/un.h>
+#include <sys/uio.h>
 #include <utility>
 #include <typeinfo>
+#include <cstdio>
 #include <cassert>
 #include <cctype>
 
 #include <Logging.h>
-#include <EventedBufferedInput.h>
 #include <MessageReadersWriters.h>
 #include <Constants.h>
-#include <UnionStation/Core.h>
-#include <UnionStation/Transaction.h>
-#include <UnionStation/ScopeLog.h>
-#include <ApplicationPool2/Pool.h>
+#include <ServerKit/Errors.h>
+#include <ServerKit/HttpServer.h>
+#include <ServerKit/HttpHeaderParser.h>
+#include <MemoryKit/palloc.h>
+#include <DataStructures/LString.h>
+#include <DataStructures/StringKeyTable.h>
 #include <ApplicationPool2/ErrorRenderer.h>
+#include <StaticString.h>
+#include <Utils.h>
 #include <Utils/StrIntUtils.h>
 #include <Utils/IOUtils.h>
-#include <Utils/HttpHeaderBufferer.h>
+#include <Utils/JsonUtils.h>
 #include <Utils/HttpConstants.h>
-#include <Utils/Template.h>
+#include <Utils/VariantMap.h>
 #include <Utils/Timer.h>
-#include <Utils/Dechunker.h>
-#include <agents/HelperAgent/AgentOptions.h>
-#include <agents/HelperAgent/FileBackedPipe.h>
-#include <agents/HelperAgent/ScgiRequestParser.h>
+#include <agents/HelperAgent/RequestHandler/Client.h>
+#include <agents/HelperAgent/RequestHandler/AppResponse.h>
+#include <agents/HelperAgent/RequestHandler/TurboCaching.h>
 
 namespace Passenger {
 
@@ -156,2595 +160,358 @@ using namespace boost;
 using namespace oxt;
 using namespace ApplicationPool2;
 
-class RequestHandler;
-
-#define MAX_STATUS_HEADER_SIZE 64
-
-#define RH_ERROR(client, x) P_ERROR("[Client " << client->name() << "] " << x)
-#define RH_WARN(client, x) P_WARN("[Client " << client->name() << "] " << x)
-#define RH_DEBUG(client, x) P_DEBUG("[Client " << client->name() << "] " << x)
-#define RH_TRACE(client, level, x) P_TRACE(level, "[Client " << client->name() << "] " << x)
-
-#define RH_LOG_EVENT(client, eventName) \
-	char _clientName[7 + 8]; \
-	snprintf(_clientName, sizeof(_clientName), "Client %d", client->fdnum); \
-	TRACE_POINT_WITH_DATA(_clientName); \
-	RH_TRACE(client, 3, "Event: " eventName)
-
-
-class Client: public boost::enable_shared_from_this<Client> {
-private:
-	struct ev_loop *getLoop() const;
-	const SafeLibevPtr &getSafeLibev() const;
-	unsigned int getConnectPasswordTimeout(const RequestHandler *handler) const;
-
-	static size_t onClientInputData(const EventedBufferedInputPtr &source, const StaticString &data);
-	static void onClientInputError(const EventedBufferedInputPtr &source, const char *message, int errnoCode);
-
-	static void onClientBodyBufferData(const FileBackedPipePtr &source,
-		const char *data, size_t size,
-		const FileBackedPipe::ConsumeCallback &callback);
-	static void onClientBodyBufferEnd(const FileBackedPipePtr &source);
-	static void onClientBodyBufferError(const FileBackedPipePtr &source, int errorCode);
-	static void onClientBodyBufferCommit(const FileBackedPipePtr &source);
-
-	static void onClientOutputPipeData(const FileBackedPipePtr &source,
-		const char *data, size_t size,
-		const FileBackedPipe::ConsumeCallback &callback);
-	static void onClientOutputPipeEnd(const FileBackedPipePtr &source);
-	static void onClientOutputPipeError(const FileBackedPipePtr &source, int errorCode);
-	static void onClientOutputPipeCommit(const FileBackedPipePtr &source);
-
-	void onClientOutputWritable(ev::io &io, int revents);
-
-	static size_t onAppInputData(const EventedBufferedInputPtr &source, const StaticString &data);
-	static void onAppInputChunk(const char *data, size_t size, void *userData);
-	static void onAppInputChunkEnd(void *userData);
-	static void onAppInputError(const EventedBufferedInputPtr &source, const char *message, int errnoCode);
-
-	void onAppOutputWritable(ev::io &io, int revents);
-
-	void onTimeout(ev::timer &timer, int revents);
-
-
-	static const char *boolStr(bool val) {
-		static const char *strs[] = { "false", "true" };
-		return strs[val];
-	}
-
-	void resetPrimitiveFields() {
-		requestHandler = NULL;
-		state = DISCONNECTED;
-		backgroundOperations = 0;
-		requestBodyIsBuffered = false;
-		requestIsChunked = false;
-		freeBufferedConnectPassword();
-		connectedAt = 0;
-		requestBodyLength = 0;
-		requestBodyAlreadyRead = 0;
-		checkoutSessionAfterCommit = false;
-		stickySession = false;
-		sessionCheckedOut = false;
-		sessionCheckoutTry = 0;
-		responseHeaderSeen = false;
-		chunkedResponse = false;
-		responseContentLength = -1;
-		responseBodyAlreadyRead = 0;
-		appRoot.clear();
-	}
-
-	void freeScopeLogs() {
-		endScopeLog(&scopeLogs.requestProxying, false);
-		endScopeLog(&scopeLogs.getFromPool, false);
-		endScopeLog(&scopeLogs.bufferingRequestBody, false);
-		endScopeLog(&scopeLogs.requestProcessing, false);
-	}
-
-public:
-	/** Back reference to the RequestHandler that this Client is associated with.
-	 * NULL when this Client is not in the pool or is disconnected. */
-	RequestHandler *requestHandler;
-	/** File descriptor of the client socket. Is empty when this Client is not
-	 * in the pool or is disconnected. */
-	FileDescriptor fd;
-	/** The last associated file descriptor number is stored here. It is not
-	 * cleared after disassociating. Its only purpose is to make logging calls
-	 * like RH_DEBUG() print the correct client name after disconnect() is called.
-	 * Do not use this value for anything else as it may not refer to a valid
-	 * file descriptor. */
-	int fdnum;
-
-
-	/***** Client <-> RequestHandler I/O channels, pipes and watchers *****/
-
-	/** Client input channel. */
-	EventedBufferedInputPtr clientInput;
-	/** If request body buffering is turned on, it will be buffered into this FileBackedPipe. */
-	FileBackedPipePtr clientBodyBuffer;
-	/** Client output pipe. */
-	FileBackedPipePtr clientOutputPipe;
-	/** Client output channel watcher. */
-	ev::io clientOutputWatcher;
-
-
-	/***** RequestHandler <-> Application I/O channels, pipes and watchers *****/
-
-	/** Application input channel. */
-	EventedBufferedInputPtr appInput;
-	string appOutputBuffer;
-	/** Application output channel watcher. */
-	ev::io appOutputWatcher;
-
-
-	/***** State variables *****/
-
-	enum {
-		BEGIN_READING_CONNECT_PASSWORD,
-		STILL_READING_CONNECT_PASSWORD,
-		READING_HEADER,
-		BUFFERING_REQUEST_BODY,
-		CHECKING_OUT_SESSION,
-		SENDING_HEADER_TO_APP,
-		FORWARDING_BODY_TO_APP,
-
-		// Special states
-		WRITING_SIMPLE_RESPONSE,
-		DISCONNECTED
-	} state;
-
-	/* How many background operations are currently in progress, e.g.
-	 * an asyncGet() or bodyBuffer.add(). If the client is disconnected
-	 * while this flag is true, then the Client object is not reassociateable
-	 * in order to give the completion callbacks a chance to cancel properly.
-	 */
-	unsigned int backgroundOperations;
-
-	struct {
-		char *data;
-		unsigned int alreadyRead;
-	} bufferedConnectPassword;
-
-	// Used for enforcing the connection timeout.
-	ev::timer timeoutTimer;
-
-	ev_tstamp connectedAt;
-	/** The size of the request body. The request body is the part that comes
-	 * after the request headers, which may be the HTTP request message body,
-	 * but may also be any other arbitrary data that is sent over the request
-	 * socket (e.g. WebSocket data).
-	 *
-	 * Possible values:
-	 *
-	 * -1: infinite. Should keep forwarding client body until end of stream.
-	 *  0: no client body. Should stop after sending headers to application.
-	 * >0: Should forward exactly this many bytes of the client body.
-	 */
-	long long requestBodyLength;
-	unsigned long long requestBodyAlreadyRead;
-	Options options;
-	ScgiRequestParser scgiParser;
-	SessionPtr session;
-	string appRoot;
-	struct {
-		UnionStation::ScopeLog
-			*requestProcessing,
-			*bufferingRequestBody,
-			*getFromPool,
-			*requestProxying;
-	} scopeLogs;
-	unsigned int sessionCheckoutTry;
-	bool requestBodyIsBuffered;
-	bool requestIsChunked;
-	bool sessionCheckedOut;
-	bool checkoutSessionAfterCommit;
-	bool stickySession;
-
-	bool responseHeaderSeen;
-	bool chunkedResponse;
-	/** The size of the response body, set based on the values of
-	 * the Content-Length and Transfer-Encoding response headers.
-	 * Possible values:
-	 *
-	 * -1: infinite. Should keep forwarding response body until end of stream.
-	 *     This is the case for WebSockets or for responses without Content-Length.
-	 *     Responses with "Transfer-Encoding: chunked" also fall under this
-	 *     category, though in this case encountering the zero-length chunk is
-	 *     treated the same as end of stream.
-	 * 0 : no client body. Should immediately close connection after forwarding
-	 *     headers.
-	 * >0: Should forward exactly this many bytes of the response body.
-	 */
-	long long responseContentLength;
-	unsigned long long responseBodyAlreadyRead;
-	HttpHeaderBufferer responseHeaderBufferer;
-	Dechunker responseDechunker;
-
-
-	Client() {
-		fdnum = -1;
-
-		clientInput = boost::make_shared< EventedBufferedInput<> >();
-		clientInput->onData   = onClientInputData;
-		clientInput->onError  = onClientInputError;
-		clientInput->userData = this;
-
-		clientBodyBuffer = boost::make_shared<FileBackedPipe>("/tmp");
-		clientBodyBuffer->userData  = this;
-		clientBodyBuffer->onData    = onClientBodyBufferData;
-		clientBodyBuffer->onEnd     = onClientBodyBufferEnd;
-		clientBodyBuffer->onError   = onClientBodyBufferError;
-		clientBodyBuffer->onCommit  = onClientBodyBufferCommit;
-
-		clientOutputPipe = boost::make_shared<FileBackedPipe>("/tmp");
-		clientOutputPipe->userData  = this;
-		clientOutputPipe->onData    = onClientOutputPipeData;
-		clientOutputPipe->onEnd     = onClientOutputPipeEnd;
-		clientOutputPipe->onError   = onClientOutputPipeError;
-		clientOutputPipe->onCommit  = onClientOutputPipeCommit;
-
-		clientOutputWatcher.set<Client, &Client::onClientOutputWritable>(this);
-
-
-		appInput = boost::make_shared< EventedBufferedInput<> >();
-		appInput->onData   = onAppInputData;
-		appInput->onError  = onAppInputError;
-		appInput->userData = this;
-
-		appOutputWatcher.set<Client, &Client::onAppOutputWritable>(this);
-
-
-		timeoutTimer.set<Client, &Client::onTimeout>(this);
-
-
-		responseDechunker.onData = onAppInputChunk;
-		responseDechunker.onEnd = onAppInputChunkEnd;
-		responseDechunker.userData = this;
-
-
-		bufferedConnectPassword.data = NULL;
-		bufferedConnectPassword.alreadyRead = 0;
-		memset(&scopeLogs, 0, sizeof(scopeLogs));
-		resetPrimitiveFields();
-	}
-
-	~Client() {
-		if (requestHandler != NULL) {
-			discard();
-		}
-		clientInput->userData      = NULL;
-		clientBodyBuffer->userData = NULL;
-		clientOutputPipe->userData = NULL;
-		appInput->userData         = NULL;
-		freeBufferedConnectPassword();
-		freeScopeLogs();
-	}
-
-	void associate(RequestHandler *handler, const FileDescriptor &_fd) {
-		assert(requestHandler == NULL);
-		requestHandler = handler;
-		fd = _fd;
-		fdnum = _fd;
-		state = BEGIN_READING_CONNECT_PASSWORD;
-		connectedAt = ev_time();
-
-		clientInput->reset(getSafeLibev().get(), _fd);
-		clientInput->start();
-		clientBodyBuffer->reset(getSafeLibev());
-		clientOutputPipe->reset(getSafeLibev());
-		clientOutputPipe->start();
-		clientOutputWatcher.set(getLoop());
-		clientOutputWatcher.set(_fd, ev::WRITE);
-
-		// appOutputWatcher is initialized in initiateSession.
-
-		timeoutTimer.set(getLoop());
-		timeoutTimer.start(getConnectPasswordTimeout(handler) / 1000.0, 0.0);
-	}
-
-	void disassociate() {
-		assert(requestHandler != NULL);
-		resetPrimitiveFields();
-		fd = FileDescriptor();
-
-		clientInput->reset(NULL, FileDescriptor());
-		clientBodyBuffer->reset();
-		clientOutputPipe->reset();
-		clientOutputWatcher.stop();
-
-		appInput->reset(NULL, FileDescriptor());
-		appOutputBuffer.resize(0);
-		appOutputWatcher.stop();
-
-		timeoutTimer.stop();
-		scgiParser.reset();
-		session.reset();
-		responseHeaderBufferer.reset();
-		responseDechunker.reset();
-		freeScopeLogs();
-	}
-
-	void discard() {
-		assert(requestHandler != NULL);
-		resetPrimitiveFields();
-		fd = FileDescriptor();
-
-		clientInput->stop();
-		clientBodyBuffer->reset();
-		clientOutputPipe->reset();
-		clientOutputWatcher.stop();
-
-		appInput->stop();
-		appOutputWatcher.stop();
-
-		timeoutTimer.stop();
-
-		freeScopeLogs();
-
-		requestHandler = NULL;
-	}
-
-	bool reassociateable() const {
-		return requestHandler == NULL
-			&& backgroundOperations == 0
-			&& clientInput->resetable()
-			&& clientBodyBuffer->resetable()
-			&& clientOutputPipe->resetable()
-			&& appInput->resetable();
-	}
-
-	string name() const {
-		if (fdnum == -1) {
-			return "(null)";
-		} else {
-			return toString(fdnum);
-		}
-	}
-
-	bool connected() const {
-		return requestHandler != NULL;
-	}
-
-	const char *getStateName() const {
-		switch (state) {
-		case BEGIN_READING_CONNECT_PASSWORD:
-			return "BEGIN_READING_CONNECT_PASSWORD";
-		case STILL_READING_CONNECT_PASSWORD:
-			return "STILL_READING_CONNECT_PASSWORD";
-		case READING_HEADER:
-			return "READING_HEADER";
-		case BUFFERING_REQUEST_BODY:
-			return "BUFFERING_REQUEST_BODY";
-		case CHECKING_OUT_SESSION:
-			return "CHECKING_OUT_SESSION";
-		case SENDING_HEADER_TO_APP:
-			return "SENDING_HEADER_TO_APP";
-		case FORWARDING_BODY_TO_APP:
-			return "FORWARDING_BODY_TO_APP";
-		case WRITING_SIMPLE_RESPONSE:
-			return "WRITING_SIMPLE_RESPONSE";
-		case DISCONNECTED:
-			return "DISCONNECTED";
-		default:
-			return "UNKNOWN";
-		}
-	}
-
-	void freeBufferedConnectPassword() {
-		if (bufferedConnectPassword.data != NULL) {
-			free(bufferedConnectPassword.data);
-			bufferedConnectPassword.data = NULL;
-			bufferedConnectPassword.alreadyRead = 0;
-		}
-	}
-
-	/**
-	 * Checks whether we should half-close the application socket after forwarding
-	 * the request. HTTP does not formally support half-closing, and Node.js treats a
-	 * half-close as a full close, so we only half-close session sockets, not
-	 * HTTP sockets.
-	 */
-	bool shouldHalfCloseWrite() const {
-		return session->getProtocol() == "session";
-	}
-
-	bool useUnionStation() const {
-		return options.transaction != NULL;
-	}
-
-	UnionStation::TransactionPtr getUnionStationTransaction() const {
-		return options.transaction;
-	}
-
-	void beginScopeLog(UnionStation::ScopeLog **scopeLog, const char *name) {
-		if (options.transaction != NULL) {
-			*scopeLog = new UnionStation::ScopeLog(options.transaction, name);
-		}
-	}
-
-	void endScopeLog(UnionStation::ScopeLog **scopeLog, bool success = true) {
-		if (success && *scopeLog != NULL) {
-			(*scopeLog)->success();
-		}
-		delete *scopeLog;
-		*scopeLog = NULL;
-	}
-
-	void logMessage(const StaticString &message) {
-		options.transaction->message(message);
-	}
-
-	void verifyInvariants() const {
-		assert((requestHandler == NULL) == (fd == -1));
-		assert((requestHandler == NULL) == (state == DISCONNECTED));
-	}
-
-	template<typename Stream>
-	void inspect(Stream &stream) const {
-		const char *indent = "    ";
-		time_t the_time;
-		struct tm the_tm;
-		char timestr[60];
-
-		the_time = (time_t) connectedAt;
-		localtime_r(&the_time, &the_tm);
-		strftime(timestr, sizeof(timestr) - 1, "%F %H:%M:%S", &the_tm);
-
-		stream << indent << "host                        = " << (scgiParser.getHeader("HTTP_HOST").empty() ? "(empty)" : scgiParser.getHeader("HTTP_HOST")) << "\n";
-		stream << indent << "uri                         = " << (scgiParser.getHeader("REQUEST_URI").empty() ? "(empty)" : scgiParser.getHeader("REQUEST_URI")) << "\n";
-		stream << indent << "connected at                = " << timestr << " (" << (unsigned long long) (ev_time() - connectedAt) << " sec ago)\n";
-		stream << indent << "state                       = " << getStateName() << "\n";
-		if (session == NULL) {
-			stream << indent << "session                     = NULL\n";
-		} else {
-			stream << indent << "session pid                 = " << session->getPid() << " (" <<
-				session->getGroup()->name << ")\n";
-			stream << indent << "session gupid               = " << session->getGupid() << "\n";
-			stream << indent << "session initiated           = " << boolStr(session->initiated()) << "\n";
-		}
-		stream
-			<< indent << "requestBodyIsBuffered       = " << boolStr(requestBodyIsBuffered) << "\n"
-			<< indent << "requestIsChunked            = " << boolStr(requestIsChunked) << "\n"
-			<< indent << "requestBodyLength           = " << requestBodyLength << "\n"
-			<< indent << "requestBodyAlreadyRead      = " << requestBodyAlreadyRead << "\n"
-			<< indent << "responseContentLength       = " << responseContentLength << "\n"
-			<< indent << "responseBodyAlreadyRead     = " << responseBodyAlreadyRead << "\n"
-			<< indent << "clientInput                 = " << clientInput.get() <<  " " << clientInput->inspect() << "\n"
-			<< indent << "clientInput started         = " << boolStr(clientInput->isStarted()) << "\n"
-			<< indent << "clientBodyBuffer started    = " << boolStr(clientBodyBuffer->isStarted()) << "\n"
-			<< indent << "clientBodyBuffer reachedEnd = " << boolStr(clientBodyBuffer->reachedEnd()) << "\n"
-			<< indent << "clientOutputPipe started    = " << boolStr(clientOutputPipe->isStarted()) << "\n"
-			<< indent << "clientOutputPipe reachedEnd = " << boolStr(clientOutputPipe->reachedEnd()) << "\n"
-			<< indent << "clientOutputWatcher active  = " << boolStr(clientOutputWatcher.is_active()) << "\n"
-			<< indent << "appInput                    = " << appInput.get() << " " << appInput->inspect() << "\n"
-			<< indent << "appInput started            = " << boolStr(appInput->isStarted()) << "\n"
-			<< indent << "appInput reachedEnd         = " << boolStr(appInput->endReached()) << "\n"
-			<< indent << "responseHeaderSeen          = " << boolStr(responseHeaderSeen) << "\n"
-			<< indent << "useUnionStation             = " << boolStr(useUnionStation()) << "\n"
-			;
-	}
-};
-
-typedef boost::shared_ptr<Client> ClientPtr;
 
-
-class RequestHandler {
+class RequestHandler: public ServerKit::HttpServer<RequestHandler, Client> {
 public:
-	enum BenchmarkPoint {
-		BP_NONE,
-		BP_AFTER_ACCEPT,
-		BP_AFTER_CHECK_CONNECT_PASSWORD,
-		BP_AFTER_PARSING_HEADER,
-		BP_BEFORE_CHECKOUT_SESSION
+	enum BenchmarkMode {
+		BM_NONE,
+		BM_AFTER_ACCEPT,
+		BM_BEFORE_CHECKOUT,
+		BM_AFTER_CHECKOUT,
+		BM_RESPONSE_BEGIN,
+		BM_UNKNOWN
 	};
 
 private:
-	friend class Client;
+	typedef ServerKit::HttpServer<RequestHandler, Client> ParentClass;
+	typedef ServerKit::Channel Channel;
+	typedef ServerKit::FdSinkChannel FdSinkChannel;
+	typedef ServerKit::FdSourceChannel FdSourceChannel;
+	typedef ServerKit::FileBufferedChannel FileBufferedChannel;
+	typedef ServerKit::FileBufferedFdSinkChannel FileBufferedFdSinkChannel;
+
+	static const unsigned int MAX_SESSION_CHECKOUT_TRY = 10;
+
+	unsigned int statThrottleRate;
+	BenchmarkMode benchmarkMode: 3;
+	bool singleAppMode: 1;
+	bool showVersionInHeader: 1;
+	bool gracefulExit: 1;
+
+	const VariantMap *agentsOptions;
+	psg_pool_t *stringPool;
+	StringKeyTable< boost::shared_ptr<Options> > poolOptionsCache;
+
+	StaticString defaultRuby;
+	StaticString loggingAgentAddress;
+	StaticString loggingAgentPassword;
+	StaticString defaultUser;
+	StaticString defaultGroup;
+	StaticString defaultServerName;
+	StaticString defaultServerPort;
+	StaticString serverSoftware;
+
+	HashedStaticString PASSENGER_APP_GROUP_NAME;
+	HashedStaticString PASSENGER_MAX_REQUESTS;
+	HashedStaticString PASSENGER_STICKY_SESSIONS;
+	HashedStaticString PASSENGER_STICKY_SESSIONS_COOKIE_NAME;
+	HashedStaticString PASSENGER_REQUEST_OOB_WORK;
+	HashedStaticString UNION_STATION_SUPPORT;
+	HashedStaticString REMOTE_ADDR;
+	HashedStaticString REMOTE_PORT;
+	HashedStaticString REMOTE_USER;
+	HashedStaticString FLAGS;
+	HashedStaticString HTTP_COOKIE;
+	HashedStaticString HTTP_DATE;
+	HashedStaticString HTTP_HOST;
+	HashedStaticString HTTP_CONTENT_LENGTH;
+	HashedStaticString HTTP_CONTENT_TYPE;
+	HashedStaticString HTTP_EXPECT;
+	HashedStaticString HTTP_CONNECTION;
+	HashedStaticString HTTP_STATUS;
+	HashedStaticString HTTP_TRANSFER_ENCODING;
+
+	unsigned int threadNumber;
+	StaticString serverLogName;
+
+	friend class TurboCaching<Request>;
+	struct ev_check checkWatcher;
+	TurboCaching<Request> turboCaching;
+
+	#ifdef DEBUG_RH_EVENT_LOOP_BLOCKING
+		struct ev_prepare prepareWatcher;
+		ev_tstamp timeBeforeBlocking;
+	#endif
 
-	const SafeLibevPtr libev;
-	FileDescriptor requestSocket;
-	PoolPtr pool;
-	const AgentOptions &options;
-	const ResourceLocator resourceLocator;
+public:
+	ResourceLocator *resourceLocator;
+	PoolPtr appPool;
 	UnionStation::CorePtr unionStationCore;
-	ev::io requestSocketWatcher;
-	ev::timer resumeSocketWatcherTimer;
-	HashMap<int, ClientPtr> clients;
-	Timer inactivityTimer;
-	bool accept4Available;
-	boost::regex upgradeHeaderRegex;
-
-
-	void disconnect(const ClientPtr &client) {
-		// Prevent Client object from being destroyed until we're done.
-		ClientPtr reference = client;
-
-		clients.erase(client->fd);
-		client->discard();
-		client->verifyInvariants();
-		RH_DEBUG(client, "Disconnected; new client count = " << clients.size());
-
-		if (clients.empty()) {
-			inactivityTimer.start();
-		}
-	}
-
-	void disconnectWithError(const ClientPtr &client, const StaticString &message) {
-		RH_WARN(client, "Disconnecting with error: " << message);
-		if (client->useUnionStation()) {
-			client->logMessage("Disconnecting with error: " + message);
-		}
-		disconnect(client);
-	}
-
-	void disconnectWithClientSocketWriteError(const ClientPtr &client, int e) {
-		stringstream message;
-		message << "client socket write error: ";
-		message << strerror(e);
-		message << " (errno=" << e << ")";
-		disconnectWithError(client, message.str());
-	}
-
-	void disconnectWithAppSocketWriteError(const ClientPtr &client, int e) {
-		stringstream message;
-		message << "app socket write error: ";
-		message << strerror(e);
-		message << " (errno=" << e << ")";
-		disconnectWithError(client, message.str());
-	}
-
-	void disconnectWithWarning(const ClientPtr &client, const StaticString &message) {
-		P_DEBUG("Disconnected client " << client->name() << " with warning: " << message);
-		disconnect(client);
-	}
-
-	template<typename Number>
-	static Number clamp(Number n, Number min, Number max) {
-		if (n < min) {
-			return min;
-		} else if (n > max) {
-			return max;
-		} else {
-			return n;
-		}
-	}
-
-	// GDB helper function, implemented in .cpp file to prevent inlining.
-	Client *getClientPointer(const ClientPtr &client);
-
-	void doResetInactivityTime() {
-		inactivityTimer.reset();
-	}
-
-	void getInactivityTime(unsigned long long *result) const {
-		*result = inactivityTimer.elapsed();
-	}
-
-	static bool getBoolOption(const ClientPtr &client, const StaticString &name, bool defaultValue = false) {
-		ScgiRequestParser::const_iterator it = client->scgiParser.getHeaderIterator(name);
-		if (it != client->scgiParser.end()) {
-			return it->second == "true";
-		} else {
-			return defaultValue;
-		}
-	}
-
-	static long long getULongLongOption(const ClientPtr &client, const StaticString &name, long long defaultValue = -1) {
-		ScgiRequestParser::const_iterator it = client->scgiParser.getHeaderIterator(name);
-		if (it != client->scgiParser.end()) {
-			long long result = stringToULL(it->second);
-			// The client may send a malicious integer, so check for this.
-			if (result < 0) {
-				return defaultValue;
-			} else {
-				return result;
-			}
-		} else {
-			return defaultValue;
-		}
-	}
-
-	bool friendlyErrorPagesEnabled(const ClientPtr &client) const {
-		bool defaultValue = client->options.environment != "staging"
-			&& client->options.environment != "production";
-		return getBoolOption(client, "PASSENGER_FRIENDLY_ERROR_PAGES", defaultValue);
-	}
-
-	void writeSimpleResponse(const ClientPtr &client, const StaticString &data, int code = 200) {
-		char header[256], statusBuffer[50];
-		char *pos = header;
-		const char *end = header + sizeof(header) - 1;
-		const char *status;
-
-		status = getStatusCodeAndReasonPhrase(code);
-		if (status == NULL) {
-			snprintf(statusBuffer, sizeof(statusBuffer), "%d Unknown Reason-Phrase", code);
-			status = statusBuffer;
-		}
-
-		if (getBoolOption(client, "PASSENGER_STATUS_LINE", true)) {
-			pos += snprintf(pos, end - pos, "HTTP/1.1 %s\r\n",
-				status);
-		}
-		pos += snprintf(pos, end - pos,
-			"Status: %s\r\n"
-			"Content-Length: %lu\r\n"
-			"Content-Type: text/html; charset=UTF-8\r\n"
-			"Cache-Control: no-cache, no-store, must-revalidate\r\n"
-			"\r\n",
-			status, (unsigned long) data.size());
-
-		client->clientOutputPipe->write(header, pos - header);
-		if (!client->connected()) {
-			return;
-		}
-		client->clientOutputPipe->write(data.data(), data.size());
-		if (!client->connected()) {
-			return;
-		}
-		client->clientOutputPipe->end();
-		if (!client->connected()) {
-			return;
-		}
-
-		if (client->useUnionStation()) {
-			snprintf(header, end - header, "Status: %d %s",
-				code, status);
-			client->logMessage(header);
-		}
-	}
-
-	void writeErrorResponse(const ClientPtr &client, const StaticString &message, const SpawnException *e = NULL) {
-		assert(client->state < Client::FORWARDING_BODY_TO_APP);
-		client->state = Client::WRITING_SIMPLE_RESPONSE;
-
-		ErrorRenderer renderer(resourceLocator);
-		string data;
-
-		if (friendlyErrorPagesEnabled(client)) {
-			try {
-				data = renderer.renderWithDetails(message, client->options, e);
-			} catch (const SystemException &e2) {
-				P_ERROR("Cannot render an error page: " << e2.what() << "\n" <<
-					e2.backtrace());
-				data = message;
-			}
-		} else {
-			try {
-				data = renderer.renderWithoutDetails();
-			} catch (const SystemException &e2) {
-				P_ERROR("Cannot render an error page: " << e2.what() << "\n" <<
-					e2.backtrace());
-				data = "Internal Server Error";
-			}
-		}
-
-		stringstream str;
-		if (getBoolOption(client, "PASSENGER_STATUS_LINE", true)) {
-			str << "HTTP/1.1 500 Internal Server Error\r\n";
-		}
-		str << "Status: 500 Internal Server Error\r\n";
-		str << "Content-Length: " << data.size() << "\r\n";
-		str << "Content-Type: text/html; charset=UTF-8\r\n";
-		str << "Cache-Control: no-cache, no-store, must-revalidate\r\n";
-		str << "\r\n";
-
-		const string header = str.str();
-		client->clientOutputPipe->write(header.data(), header.size());
-		if (!client->connected()) {
-			return;
-		}
-		client->clientOutputPipe->write(data.data(), data.size());
-		if (!client->connected()) {
-			return;
-		}
-		client->clientOutputPipe->end();
-		if (!client->connected()) {
-			return;
-		}
-
-		if (client->useUnionStation()) {
-			client->logMessage("Status: 500 Internal Server Error");
-			// TODO: record error message
-		}
-	}
-
-	static BenchmarkPoint getDefaultBenchmarkPoint() {
-		const char *val = getenv("PASSENGER_REQUEST_HANDLER_BENCHMARK_POINT");
-		if (val == NULL || *val == '\0') {
-			return BP_NONE;
-		} else if (strcmp(val, "after_accept") == 0) {
-			return BP_AFTER_ACCEPT;
-		} else if (strcmp(val, "after_check_connect_password") == 0) {
-			return BP_AFTER_CHECK_CONNECT_PASSWORD;
-		} else if (strcmp(val, "after_parsing_header") == 0) {
-			return BP_AFTER_PARSING_HEADER;
-		} else if (strcmp(val, "before_checkout_session") == 0) {
-			return BP_BEFORE_CHECKOUT_SESSION;
-		} else {
-			P_WARN("Invalid RequestHandler benchmark point requested: " << val);
-			return BP_NONE;
-		}
-	}
-
-
-	/*****************************************************
-	 * COMPONENT: appInput -> clientOutputPipe plumbing
-	 *
-	 * The following code receives data from appInput,
-	 * possibly modifies it, and forwards it to
-	 * clientOutputPipe.
-	 *****************************************************/
-
-	struct Header {
-		StaticString key;
-		StaticString value;
-
-		Header() { }
-
-		Header(const StaticString &_key, const StaticString &_value)
-			: key(_key),
-			  value(_value)
-			{ }
-
-		bool empty() const {
-			return key.empty();
-		}
-
-		const char *begin() const {
-			return key.data();
-		}
-
-		const char *end() const {
-			return value.data() + value.size() + sizeof("\r\n") - 1;
-		}
-
-		size_t size() const {
-			return end() - begin();
-		}
-	};
-
-	/** Given a substring containing the start of the header value,
-	 * extracts the substring that contains a single header value.
-	 *
-	 *   const char *data =
-	 *      "Status: 200 OK\r\n"
-	 *      "Foo: bar\r\n";
-	 *   extractHeaderValue(data + strlen("Status:"), strlen(data) - strlen("Status:"));
-	 *      // "200 OK"
-	 */
-	static StaticString extractHeaderValue(const char *data, size_t size) {
-		const char *start = data;
-		const char *end   = data + size;
-		const char *terminator;
-
-		while (start < end && *start == ' ') {
-			start++;
-		}
-
-		terminator = (const char *) memchr(start, '\r', end - start);
-		if (terminator == NULL) {
-			return StaticString();
-		} else {
-			return StaticString(start, terminator - start);
-		}
-	}
 
-	static Header lookupHeader(const StaticString &headerData, const StaticString &name) {
-		string::size_type searchStart = 0;
-		while (searchStart < headerData.size()) {
-			string::size_type pos = headerData.find(name, searchStart);
-			if (OXT_UNLIKELY(pos == string::npos)) {
-				return Header();
-			} else if ((pos == 0 || headerData[pos - 1] == '\n')
-				&& headerData.size() > pos + name.size()
-				&& headerData[pos + name.size()] == ':')
-			{
-				StaticString value = extractHeaderValue(
-					headerData.data() + pos + name.size() + 1,
-					headerData.size() - pos - name.size() - 1);
-				return Header(headerData.substr(pos, name.size()), value);
-			} else {
-				searchStart = pos + name.size() + 1;
-			}
-		}
-		return Header();
-	}
+protected:
+	#include <agents/HelperAgent/RequestHandler/Utils.cpp>
+	#include <agents/HelperAgent/RequestHandler/Hooks.cpp>
+	#include <agents/HelperAgent/RequestHandler/InitRequest.cpp>
+	#include <agents/HelperAgent/RequestHandler/BufferBody.cpp>
+	#include <agents/HelperAgent/RequestHandler/CheckoutSession.cpp>
+	#include <agents/HelperAgent/RequestHandler/SendRequest.cpp>
+	#include <agents/HelperAgent/RequestHandler/ForwardResponse.cpp>
 
-	static Header lookupHeader(const StaticString &headerData, const StaticString &name,
-		const StaticString &name2)
+public:
+	RequestHandler(ServerKit::Context *context, const VariantMap *_agentsOptions,
+		unsigned int _threadNumber = 1)
+		: ParentClass(context),
+
+		  statThrottleRate(_agentsOptions->getInt("stat_throttle_rate")),
+		  benchmarkMode(parseBenchmarkMode(_agentsOptions->get("benchmark_mode", false))),
+		  singleAppMode(false),
+		  showVersionInHeader(_agentsOptions->getBool("show_version_in_header")),
+		  gracefulExit(_agentsOptions->getBool("server_graceful_exit")),
+
+		  agentsOptions(_agentsOptions),
+		  stringPool(psg_create_pool(1024 * 4)),
+		  poolOptionsCache(4),
+
+		  PASSENGER_APP_GROUP_NAME("!~PASSENGER_APP_GROUP_NAME"),
+		  PASSENGER_MAX_REQUESTS("!~PASSENGER_MAX_REQUESTS"),
+		  PASSENGER_STICKY_SESSIONS("!~PASSENGER_STICKY_SESSIONS"),
+		  PASSENGER_STICKY_SESSIONS_COOKIE_NAME("!~PASSENGER_STICKY_SESSIONS_COOKIE_NAME"),
+		  PASSENGER_REQUEST_OOB_WORK("!~Request-OOB-Work"),
+		  UNION_STATION_SUPPORT("!~UNION_STATION_SUPPORT"),
+		  REMOTE_ADDR("!~REMOTE_ADDR"),
+		  REMOTE_PORT("!~REMOTE_PORT"),
+		  REMOTE_USER("!~REMOTE_USER"),
+		  FLAGS("!~FLAGS"),
+		  HTTP_COOKIE("cookie"),
+		  HTTP_DATE("date"),
+		  HTTP_HOST("host"),
+		  HTTP_CONTENT_LENGTH("content-length"),
+		  HTTP_CONTENT_TYPE("content-type"),
+		  HTTP_EXPECT("expect"),
+		  HTTP_CONNECTION("connection"),
+		  HTTP_STATUS("status"),
+		  HTTP_TRANSFER_ENCODING("transfer-encoding"),
+
+		  threadNumber(_threadNumber),
+		  turboCaching(getTurboCachingInitialState(_agentsOptions))
 	{
-		Header header = lookupHeader(headerData, name);
-		if (header.empty()) {
-			header = lookupHeader(headerData, name2);
-		}
-		return header;
-	}
-
-	bool addStatusHeaderFromStatusLine(const ClientPtr &client, string &headerData) {
-		string::size_type begin, end;
-
-		begin = headerData.find(' ');
-		if (begin != string::npos) {
-			end = headerData.find("\r\n", begin + 1);
-		} else {
-			end = string::npos;
-		}
-		if (begin != string::npos && end != string::npos) {
-			StaticString statusValue(headerData.data() + begin + 1, end - begin);
-			if (statusValue.size() <= MAX_STATUS_HEADER_SIZE) {
-				char header[MAX_STATUS_HEADER_SIZE + sizeof("Status: \r\n")];
-				char *pos = header;
-				const char *end = header + sizeof(header);
-
-				pos = appendData(pos, end, "Status: ");
-				pos = appendData(pos, end, statusValue);
-				pos = appendData(pos, end, "\r\n");
-				headerData.append(StaticString(header, pos - header));
-				return true;
-			} else {
-				disconnectWithError(client, "application sent malformed response: the Status header's (" +
-					statusValue + ") exceeds the allowed limit of " +
-					toString(MAX_STATUS_HEADER_SIZE) + " bytes.");
-				return false;
-			}
-		} else {
-			disconnectWithError(client, "application sent malformed response: the HTTP status line is invalid.");
-			return false;
-		}
+		defaultRuby = psg_pstrdup(stringPool,
+			agentsOptions->get("default_ruby"));
+		loggingAgentAddress = psg_pstrdup(stringPool,
+			agentsOptions->get("logging_agent_address", false));
+		loggingAgentPassword = psg_pstrdup(stringPool,
+			agentsOptions->get("logging_agent_password", false));
+		defaultUser = psg_pstrdup(stringPool,
+			agentsOptions->get("default_user", false));
+		defaultGroup = psg_pstrdup(stringPool,
+			agentsOptions->get("default_group", false));
+		defaultServerName = psg_pstrdup(stringPool,
+			agentsOptions->get("default_server_name"));
+		defaultServerPort = psg_pstrdup(stringPool,
+			agentsOptions->get("default_server_port"));
+		serverSoftware = psg_pstrdup(stringPool,
+			agentsOptions->get("server_software"));
+
+		generateServerLogName(_threadNumber);
+
+		if (!agentsOptions->getBool("multi_app")) {
+			boost::shared_ptr<Options> options = boost::make_shared<Options>();
+
+			singleAppMode = true;
+			fillPoolOptionsFromAgentsOptions(*options);
+
+			options->appRoot = psg_pstrdup(stringPool,
+				agentsOptions->get("app_root"));
+			options->environment = psg_pstrdup(stringPool,
+				agentsOptions->get("environment"));
+			options->appType = psg_pstrdup(stringPool,
+				agentsOptions->get("app_type"));
+			options->startupFile = psg_pstrdup(stringPool,
+				agentsOptions->get("startup_file"));
+			poolOptionsCache.insert(options->getAppGroupName(), options);
+		}
+
+		ev_check_init(&checkWatcher, onEventLoopCheck);
+		ev_set_priority(&checkWatcher, EV_MAXPRI);
+		ev_check_start(getLoop(), &checkWatcher);
+		checkWatcher.data = this;
+
+		#ifdef DEBUG_RH_EVENT_LOOP_BLOCKING
+			ev_prepare_init(&prepareWatcher, onEventLoopPrepare);
+			ev_prepare_start(getLoop(), &prepareWatcher);
+			prepareWatcher.data = this;
+
+			timeBeforeBlocking = 0;
+		#endif
 	}
 
-	static bool addReasonPhrase(string &headerData, const Header &status) {
-		if (status.value.find(' ') == string::npos) {
-			int statusCode = stringToInt(status.value);
-			const char *statusCodeAndReasonPhrase = getStatusCodeAndReasonPhrase(statusCode);
-			char newStatus[100];
-			char *pos = newStatus;
-			const char *end = newStatus + sizeof(newStatus);
-
-			pos = appendData(pos, end, "Status: ");
-			if (statusCodeAndReasonPhrase == NULL) {
-				pos = appendData(pos, end, toString(statusCode));
-				pos = appendData(pos, end, " Unknown Reason-Phrase\r\n");
-			} else {
-				pos = appendData(pos, end, statusCodeAndReasonPhrase);
-				pos = appendData(pos, end, "\r\n");
-			}
-
-			headerData.replace(status.begin() - headerData.data(), status.size(),
-				newStatus, pos - newStatus);
-			return true;
-		} else {
-			return false;
-		}
+	~RequestHandler() {
+		psg_destroy_pool(stringPool);
 	}
 
-	bool removeStatusLine(const ClientPtr &client, string &headerData) {
-		string::size_type end = headerData.find("\r\n");
-		if (end != string::npos) {
-			headerData.erase(0, end + 2);
-			return true;
+	static BenchmarkMode parseBenchmarkMode(const StaticString mode) {
+		if (mode.empty()) {
+			return BM_NONE;
+		} else if (mode == "after_accept") {
+			return BM_AFTER_ACCEPT;
+		} else if (mode == "before_checkout") {
+			return BM_BEFORE_CHECKOUT;
+		} else if (mode == "after_checkout") {
+			return BM_AFTER_CHECKOUT;
+		} else if (mode == "response_begin") {
+			return BM_RESPONSE_BEGIN;
 		} else {
-			disconnectWithError(client, "application sent malformed response: the HTTP status line is invalid.");
-			return false;
+			return BM_UNKNOWN;
 		}
 	}
 
-	static void addStatusLineFromStatusHeader(string &headerData, const Header &status) {
-		char statusLine[100];
-		char *pos = statusLine;
-		const char *end = statusLine + sizeof(statusLine);
-
-		pos = appendData(pos, end, "HTTP/1.1 ");
-		pos = appendData(pos, end, status.value);
-		pos = appendData(pos, end, "\r\n");
-
-		headerData.insert(0, statusLine, pos - statusLine);
-	}
-
-	static void removeHeader(string &headerData, const Header &header) {
-		headerData.erase(header.begin() - headerData.data(), header.size());
-	}
-
-	/*
-	 * Given a full header, possibly modify the header and send it to the clientOutputPipe.
-	 */
-	bool processResponseHeader(const ClientPtr &client,
-		const StaticString &origHeaderData)
-	{
-		string headerData;
-		headerData.reserve(origHeaderData.size() + 150);
-		// Strip trailing CRLF.
-		headerData.append(origHeaderData.data(), origHeaderData.size() - 2);
-
-		if (startsWith(headerData, "HTTP/1.")) {
-			Header status = lookupHeader(headerData, "Status", "status");
-			if (status.empty()) {
-				// Add status header if necessary.
-				if (!addStatusHeaderFromStatusLine(client, headerData)) {
-					return false;
-				}
-			} else {
-				// Add reason phrase to existing status header if necessary.
-				addReasonPhrase(headerData, status);
-			}
-			// Remove status line if necesary.
-			if (!getBoolOption(client, "PASSENGER_STATUS_LINE", true)) {
-				if (!removeStatusLine(client, headerData)) {
-					return false;
-				}
-			}
-		} else {
-			Header status = lookupHeader(headerData, "Status", "status");
-			if (!status.empty()) {
-				// Add reason phrase to status header if necessary.
-				if (addReasonPhrase(headerData, status)) {
-					status = lookupHeader(headerData, "Status", "status");
-				}
-				// Add status line if necessary.
-				if (getBoolOption(client, "PASSENGER_STATUS_LINE", true)) {
-					addStatusLineFromStatusHeader(headerData, status);
-				}
-			} else {
-				disconnectWithError(client, "application sent malformed response: it didn't send an HTTP status line or a Status header.");
-				return false;
-			}
-		}
-
-		if (client->useUnionStation()) {
-			Header status = lookupHeader(headerData, "Status", "status");
-			string message = "Status: ";
-			message.append(status.value);
-			client->logMessage(message);
+	void initialize() {
+		TRACE_POINT();
+		if (resourceLocator == NULL) {
+			throw RuntimeException("ResourceLocator not initialized");
 		}
-
-		// Process chunked transfer encoding.
-		Header transferEncoding = lookupHeader(headerData, "Transfer-Encoding", "transfer-encoding");
-		if (!transferEncoding.empty() && transferEncoding.value == "chunked") {
-			RH_TRACE(client, 3, "Response with chunked transfer encoding detected.");
-			client->chunkedResponse = true;
-			removeHeader(headerData, transferEncoding);
-		} else {
-			Header contentLength = lookupHeader(headerData, "Content-Length", "content-length");
-			if (!contentLength.empty()) {
-				client->responseContentLength = stringToLL(contentLength.value);
-			}
+		if (appPool == NULL) {
+			throw RuntimeException("AppPool not initialized");
 		}
-
-		Header connection = lookupHeader(headerData, "Connection", "connection");
-		if (!connection.empty() && (connection.value == "keep-alive"
-			|| connection.value == "Keep-Alive"))
-		{
-			RH_TRACE(client, 3, "Keep-alive response detected. Changing to non-keep alive.");
-			removeHeader(headerData, connection);
-			headerData.append("Connection: close\r\n");
+		if (unionStationCore == NULL) {
+			unionStationCore = appPool->getUnionStationCore();
 		}
+	}
 
-		// Add X-Powered-By.
-		if (getBoolOption(client, "PASSENGER_SHOW_VERSION_IN_HEADER", true)) {
-			headerData.append("X-Powered-By: Phusion Passenger " PASSENGER_VERSION "\r\n");
-		} else {
-			headerData.append("X-Powered-By: Phusion Passenger\r\n");
-		}
+	void disconnectLongRunningConnections(const StaticString &gupid) {
+		vector<Client *> clients;
+		vector<Client *>::iterator v_it, v_end;
+		Client *client;
 
-		// Add sticky session ID.
-		if (client->stickySession && client->session != NULL) {
-			StaticString baseURI = client->scgiParser.getHeader("SCRIPT_NAME");
-			if (baseURI.empty()) {
-				baseURI = StaticString("/", 1);
-			}
+		// We collect all clients in a vector so that we don't have to worry about
+		// `activeClients` being mutated while we work.
+		TAILQ_FOREACH (client, &activeClients, nextClient.activeOrDisconnectedClient) {
+			P_ASSERT_EQ(client->getConnState(), Client::ACTIVE);
+			if (client->currentRequest != NULL) {
+				Request *req = client->currentRequest;
+				if (req->httpState >= Request::COMPLETE
+				 && req->upgraded()
+				 && req->session != NULL
+				 && req->session->getGupid() == gupid)
+				{
+					if (getLogLevel() >= LVL_INFO) {
+						char clientName[32];
+						unsigned int size;
+						const LString *host;
+						StaticString hostStr;
 
-			StaticString cookieName = getStickySessionCookieName(client);
-			// Note that we do NOT set HttpOnly. If we set that flag then Chrome
-			// doesn't send cookies over WebSocket handshakes. Confirmed on Chrome 25.
-			headerData.append("Set-Cookie: ");
-			headerData.append(cookieName.data(), cookieName.size());
-			headerData.append("=");
-			headerData.append(toString(client->session->getStickySessionId()));
-			headerData.append("; Path=");
-			headerData.append(baseURI.data(), baseURI.size());
-			headerData.append("\r\n");
-
-			// Invalidate all cookies with a different route.
-			//
-			// TODO: This is not entirely correct. Clients MAY send multiple Cookie
-			// headers, although this is in practice extremely rare.
-			// http://stackoverflow.com/questions/16305814/are-multiple-cookie-headers-allowed-in-an-http-request
-			StaticString cookieHeader = client->scgiParser.getHeader("HTTP_COOKIE");
-			vector< pair<StaticString, StaticString> > cookies;
-			pair<StaticString, StaticString> cookie;
-
-			parseCookieHeader(cookieHeader, cookies);
-
-			foreach (cookie, cookies) {
-				if (cookie.first == cookieName) {
-					unsigned int stickySessionId = stringToUint(cookie.second);
-					if (stickySessionId != client->session->getStickySessionId()) {
-						headerData.append("Set-Cookie: ");
-						headerData.append(cookie.first.data(), cookie.first.size());
-						headerData.append("=");
-						headerData.append(cookie.second.data(), cookie.second.size());
-						headerData.append("; Path=");
-						headerData.append(baseURI.data(), baseURI.size());
-						headerData.append("; Expires=Thu, 01 Jan 1970 00:00:00 GMT\r\n");
+						size = getClientName(client, clientName, sizeof(clientName));
+						if (req->host != NULL) {
+							host = psg_lstr_make_contiguous(req->host, req->pool);
+							hostStr = StaticString(host->start->data, host->size);
+						}
+						P_INFO("[" << getServerName() << "] Disconnecting client " <<
+							StaticString(clientName, size) << ": " <<
+							hostStr << StaticString(req->path.start->data, req->path.size));
 					}
+					refClient(client, __FILE__, __LINE__);
+					clients.push_back(client);
 				}
 			}
 		}
 
-		// Add Date header. https://code.google.com/p/phusion-passenger/issues/detail?id=485
-		if (lookupHeader(headerData, "Date", "date").empty()) {
-			char dateStr[60];
-			char *pos = dateStr;
-			const char *end = dateStr + sizeof(dateStr) - 1;
-			time_t the_time = time(NULL);
-			struct tm the_tm;
-
-			pos = appendData(pos, end, "Date: ");
-			gmtime_r(&the_time, &the_tm);
-			pos += strftime(pos, end - pos, "%a, %d %b %Y %H:%M:%S %Z", &the_tm);
-			pos = appendData(pos, end, "\r\n");
-			headerData.append(dateStr, pos - dateStr);
-		}
-
-		// Detect out of band work request
-		Header oobw = lookupHeader(headerData, "X-Passenger-Request-OOB-Work", "x-passenger-request-oob-work");
-		if (!oobw.empty()) {
-			P_TRACE(3, "Response with oobw detected.");
-			if (client->session != NULL) {
-				client->session->requestOOBW();
-			}
-			removeHeader(headerData, oobw);
+		// Disconnect each eligible client.
+		v_end = clients.end();
+		for (v_it = clients.begin(); v_it != v_end; v_it++) {
+			client = *v_it;
+			Client *c = client;
+			disconnect(&client);
+			unrefClient(c, __FILE__, __LINE__);
 		}
-
-		P_TRACE(2, "Fowarding response header from app client: " << headerData);
-		headerData.append("\r\n");
-		writeToClientOutputPipe(client, headerData);
-		return true;
 	}
 
-	void writeToClientOutputPipe(const ClientPtr &client, const StaticString &data) {
-		bool wasCommittingToDisk = client->clientOutputPipe->isCommittingToDisk();
-		bool nowCommittingToDisk = !client->clientOutputPipe->write(data.data(), data.size());
-		if (!client->connected()) {
-			// EPIPE/ECONNRESET detected.
-			return;
-		}
-		if (!wasCommittingToDisk && nowCommittingToDisk) {
-			RH_TRACE(client, 3, "Buffering response data to disk; temporarily stopping application socket.");
-			client->backgroundOperations++;
-			// If the data comes from writeErrorResponse(), then appInput is not available.
-			if (client->session != NULL && client->session->initiated()) {
-				client->appInput->stop();
-			}
-		}
+	virtual Json::Value getConfigAsJson() const {
+		Json::Value doc = ParentClass::getConfigAsJson();
+		doc["single_app_mode"] = singleAppMode;
+		doc["stat_throttle_rate"] = statThrottleRate;
+		doc["show_version_in_header"] = showVersionInHeader;
+		doc["data_buffer_dir"] = getContext()->defaultFileBufferedChannelConfig.bufferDir;
+		return doc;
 	}
 
-	size_t onAppInputData(const ClientPtr &client, const StaticString &data) {
-		RH_LOG_EVENT(client, "onAppInputData");
-		if (!client->connected()) {
-			return 0;
+	virtual void configure(const Json::Value &doc) {
+		ParentClass::configure(doc);
+		if (doc.isMember("show_version_in_header")) {
+			showVersionInHeader = doc["show_version_in_header"].asBool();
 		}
-
-		if (!data.empty()) {
-			RH_TRACE(client, 3, "Application sent data: \"" << cEscapeString(data) << "\"");
-
-			// Buffer the application response until we've encountered the end of the header.
-			if (!client->responseHeaderSeen) {
-				size_t consumed = client->responseHeaderBufferer.feed(data.data(), data.size());
-				if (!client->responseHeaderBufferer.acceptingInput()) {
-					if (client->responseHeaderBufferer.hasError()) {
-						disconnectWithError(client, "application response format error (invalid header)");
-					} else {
-						// Now that we have a full header, do something with it.
-						RH_TRACE(client, 3, "Response header fully buffered");
-						client->responseHeaderSeen = true;
-						StaticString header = client->responseHeaderBufferer.getData();
-						if (processResponseHeader(client, header)) {
-							if (client->responseContentLength == 0) {
-								RH_TRACE(client, 3, "Disconnecting client because response Content-Length = 0");
-								onAppInputEof(client);
-							}
-							return consumed;
-						} else {
-							assert(!client->connected());
-						}
-					}
-				}
-			// The header has already been processed so forward it
-			// directly to clientOutputPipe, possibly through a
-			// dechunker first.
-			} else if (client->chunkedResponse) {
-				client->responseDechunker.feed(data.data(), data.size());
-			} else {
-				onAppInputChunk(client, data);
-			}
-			return data.size();
-
-		} else {
-			onAppInputEof(client);
-			return 0;
+		if (doc.isMember("data_buffer_dir")) {
+			getContext()->defaultFileBufferedChannelConfig.bufferDir =
+				doc["data_buffer_dir"].asString();
 		}
 	}
 
-	void onAppInputChunk(const ClientPtr &client, const StaticString &data) {
-		RH_LOG_EVENT(client, "onAppInputChunk");
-		StaticString data2;
-
-		if (client->responseContentLength == -1) {
-			data2 = data;
-		} else {
-			size_t rest = client->responseContentLength -
-				client->responseBodyAlreadyRead;
-			data2 = StaticString(data.data(), std::min<size_t>(
-				rest, data.size()));
-		}
-
-		client->responseBodyAlreadyRead += data2.size();
-		assert(client->responseContentLength == -1 || client->responseBodyAlreadyRead <=
-			(unsigned long long) client->responseContentLength);
-		if (data2.empty()) {
-			// Client sent more data than was advertised through
-			// Content-Length. Ignore them.
-			return;
-		}
-
-		writeToClientOutputPipe(client, data2);
-
-		if (client->responseContentLength > 0) {
-			RH_TRACE(client, 3, client->responseBodyAlreadyRead << "/" <<
-				client->responseContentLength <<
-				" bytes of application data forwarded so far.");
-
-			if (client->connected() && (unsigned long long) client->responseContentLength
-				== client->responseBodyAlreadyRead)
-			{
-				RH_TRACE(client, 3, "Disconnecting client because application data has been fully forwarded.");
-				onAppInputEof(client);
-			}
+	virtual Json::Value inspectStateAsJson() const {
+		Json::Value doc = ParentClass::inspectStateAsJson();
+		if (turboCaching.isEnabled()) {
+			Json::Value subdoc;
+			subdoc["fetches"] = turboCaching.responseCache.getFetches();
+			subdoc["hits"] = turboCaching.responseCache.getHits();
+			subdoc["hit_ratio"] = turboCaching.responseCache.getHitRatio();
+			subdoc["stores"] = turboCaching.responseCache.getStores();
+			subdoc["store_successes"] = turboCaching.responseCache.getStoreSuccesses();
+			subdoc["store_success_ratio"] = turboCaching.responseCache.getStoreSuccessRatio();
+			doc["turbocaching"] = subdoc;
 		}
+		return doc;
 	}
 
-	void onAppInputChunkEnd(const ClientPtr &client) {
-		RH_LOG_EVENT(client, "onAppInputChunkEnd");
-		onAppInputEof(client);
+	virtual Json::Value inspectClientStateAsJson(const Client *client) const {
+		Json::Value doc = ParentClass::inspectClientStateAsJson(client);
+		doc["connected_at"] = timeToJson(client->connectedAt * 1000000.0);
+		return doc;
 	}
 
-	void onAppInputEof(const ClientPtr &client) {
-		RH_LOG_EVENT(client, "onAppInputEof");
-		// Check for session == NULL in order to avoid executing the code twice on
-		// responses with chunked encoding.
-		// This also ensures that when onAppInputEof() is called twice (e.g. because
-		// additional data was received after onAppInputChunk has already called onAppInputEof()),
-		// we don't do things twice.
-		if (!client->connected() || client->session == NULL) {
-			return;
-		}
-
-		RH_DEBUG(client, "Application sent EOF");
-		client->appInput->stop();
-		client->session.reset();
-		client->endScopeLog(&client->scopeLogs.requestProxying);
-		client->clientOutputPipe->end();
-	}
+	virtual Json::Value inspectRequestStateAsJson(const Request *req) const {
+		Json::Value doc = ParentClass::inspectRequestStateAsJson(req);
+		Json::Value flags;
 
-	void onAppInputError(const ClientPtr &client, const char *message, int errorCode) {
-		RH_LOG_EVENT(client, "onAppInputError");
-		if (!client->connected()) {
-			return;
+		if (req->startedAt != 0) {
+			doc["started_at"] = timeToJson(req->startedAt * 1000000.0);
 		}
-
-		if (errorCode == ECONNRESET) {
-			// We might as well treat ECONNRESET like an EOF.
-			// http://stackoverflow.com/questions/2974021/what-does-econnreset-mean-in-the-context-of-an-af-local-socket
-			onAppInputEof(client);
-		} else {
-			stringstream message;
-			message << "application socket read error: ";
-			message << strerror(errorCode);
-			message << " (fd=" << client->appInput->getFd();
-			message << ", errno=" << errorCode << ")";
-			disconnectWithError(client, message.str());
+		doc["state"] = req->getStateString();
+		if (req->stickySession) {
+			doc["sticky_session_id"] = req->options.stickySessionId;
 		}
-	}
+		doc["sticky_session"] = req->stickySession;
+		doc["session_checkout_try"] = req->sessionCheckoutTry;
 
-	void onClientOutputPipeCommit(const ClientPtr &client) {
-		RH_LOG_EVENT(client, "onClientOutputPipeCommit");
-		if (!client->connected()) {
-			return;
-		}
+		flags["dechunk_response"] = req->dechunkResponse;
+		flags["request_body_buffering"] = req->requestBodyBuffering;
+		flags["https"] = req->https;
+		doc["flags"] = flags;
 
-		RH_TRACE(client, 3, "Done buffering response data to disk; resuming application socket.");
-		client->backgroundOperations--;
-		// If the data comes from writeErrorResponse(), then appInput is not available.
-		if (client->session != NULL && client->session->initiated()) {
-			client->appInput->start();
+		if (req->requestBodyBuffering) {
+			doc["body_bytes_buffered"] = (Json::Value::UInt64) req->bodyBytesBuffered;
 		}
-	}
-
 
-	/*****************************************************
-	 * COMPONENT: clientOutputPipe -> client fd plumbing
-	 *
-	 * The following code handles forwarding data from
-	 * clientOutputPipe to the client socket.
-	 *****************************************************/
+		if (req->session != NULL) {
+			Json::Value &sessionDoc = doc["session"] = Json::Value(Json::objectValue);
+			const Session *session = req->session.get();
+			const AppResponse *resp = &req->appResponse;
 
-	void onClientOutputPipeData(const ClientPtr &client, const char *data,
-		size_t size, const FileBackedPipe::ConsumeCallback &consumed)
-	{
-		RH_LOG_EVENT(client, "onClientOutputPipeData");
-		if (!client->connected()) {
-			return;
-		}
-
-		RH_TRACE(client, 3, "Forwarding " << size << " bytes of application data to client.");
-		ssize_t ret = syscalls::write(client->fd, data, size);
-		if (ret == -1) {
-			int e = errno;
-			RH_TRACE(client, 3, "Could not write to client socket: " << strerror(e) << " (errno=" << e << ")");
-			if (e == EAGAIN) {
-				RH_TRACE(client, 3, "Waiting until the client socket is writable again.");
-				client->clientOutputWatcher.start();
-				consumed(0, true);
-			} else if (e == EPIPE || e == ECONNRESET) {
-				// If the client closed the connection then disconnect quietly.
-				RH_TRACE(client, 3, "Client stopped reading prematurely");
-				if (client->useUnionStation()) {
-					client->logMessage("Disconnecting: client stopped reading prematurely");
+			if (req->session->isClosed()) {
+				sessionDoc["closed"] = true;
+			} else {
+				sessionDoc["pid"] = session->getPid();
+				sessionDoc["gupid"] = session->getGupid().toString();
+			}
+
+			doc["app_response_http_state"] = resp->getHttpStateString();
+			doc["app_response_http_major"] = resp->httpMajor;
+			doc["app_response_http_minor"] = resp->httpMinor;
+			doc["app_response_want_keep_alive"] = resp->wantKeepAlive;
+			doc["app_response_body_type"] = resp->getBodyTypeString();
+			doc["app_response_body_fully_read"] = resp->bodyFullyRead();
+			doc["app_response_body_already_read"] = (Json::Value::UInt64)
+				resp->bodyAlreadyRead;
+			if (resp->httpState != AppResponse::ERROR) {
+				if (resp->bodyType == AppResponse::RBT_CONTENT_LENGTH) {
+					doc["app_response_content_length"] = (Json::Value::UInt64)
+						resp->aux.bodyInfo.contentLength;
+				} else if (resp->bodyType == AppResponse::RBT_CHUNKED) {
+					doc["app_response_end_chunk_reached"] = resp->aux.bodyInfo.endChunkReached;
 				}
-				disconnect(client);
 			} else {
-				disconnectWithClientSocketWriteError(client, e);
+				doc["parse_error"] = ServerKit::getErrorDesc(resp->aux.parseError);
 			}
-		} else {
-			RH_TRACE(client, 3, "Managed to forward " << ret << " bytes.");
-			consumed(ret, false);
-		}
-	}
-
-	void onClientOutputPipeEnd(const ClientPtr &client) {
-		RH_LOG_EVENT(client, "onClientOutputPipeEnd");
-		if (!client->connected()) {
-			return;
-		}
-
-		RH_TRACE(client, 2, "Client output pipe ended; disconnecting client");
-		client->endScopeLog(&client->scopeLogs.requestProcessing);
-		disconnect(client);
-	}
-
-	void onClientOutputPipeError(const ClientPtr &client, int errorCode) {
-		RH_LOG_EVENT(client, "onClientOutputPipeError");
-		if (!client->connected()) {
-			return;
 		}
 
-		stringstream message;
-		message << "client output pipe error: ";
-		message << strerror(errorCode);
-		message << " (errno=" << errorCode << ")";
-		disconnectWithError(client, message.str());
-	}
-
-	void onClientOutputWritable(const ClientPtr &client) {
-		RH_LOG_EVENT(client, "onClientOutputWritable");
-		if (!client->connected()) {
-			return;
-		}
-
-		// Continue forwarding output data to the client.
-		RH_TRACE(client, 3, "Client socket became writable again.");
-		client->clientOutputWatcher.stop();
-		assert(!client->clientOutputPipe->isStarted());
-		client->clientOutputPipe->start();
-	}
-
-
-	/*****************************************************
-	 * COMPONENT: client acceptor
-	 *
-	 * The following code accepts new client connections
-	 * and forwards events to the appropriate functions
-	 * depending on the client state.
-	 *****************************************************/
-
-	FileDescriptor acceptNonBlockingSocket(int sock) {
-		union {
-			struct sockaddr_in inaddr;
-			struct sockaddr_un unaddr;
-		} u;
-		socklen_t addrlen = sizeof(u);
-
-		if (accept4Available) {
-			FileDescriptor fd(callAccept4(requestSocket,
-				(struct sockaddr *) &u, &addrlen, O_NONBLOCK));
-			// FreeBSD returns EINVAL if accept4() is called with invalid flags.
-			if (fd == -1 && (errno == ENOSYS || errno == EINVAL)) {
-				accept4Available = false;
-				return acceptNonBlockingSocket(sock);
-			} else {
-				return fd;
-			}
-		} else {
-			FileDescriptor fd(syscalls::accept(requestSocket,
-				(struct sockaddr *) &u, &addrlen));
-			if (fd != -1) {
-				int e = errno;
-				setNonBlocking(fd);
-				errno = e;
-			}
-			return fd;
-		}
-	}
-
-
-	void onResumeSocketWatcher(ev::timer &timer, int revents) {
-		P_INFO("Resuming listening on server socket.");
-		resumeSocketWatcherTimer.stop();
-		requestSocketWatcher.start();
-	}
-
-	void onAcceptable(ev::io &io, int revents) {
-		bool endReached = false;
-		unsigned int count = 0;
-		unsigned int maxAcceptTries = clamp<unsigned int>(clients.size(), 1, 10);
-		ClientPtr acceptedClients[10];
-
-		while (!endReached && count < maxAcceptTries) {
-			FileDescriptor fd = acceptNonBlockingSocket(requestSocket);
-			if (fd == -1) {
-				if (errno == EAGAIN || errno == EWOULDBLOCK) {
-					endReached = true;
-				} else {
-					int e = errno;
-					P_ERROR("Cannot accept client: " << strerror(e) <<
-						" (errno=" << e << "). " <<
-						"Pausing listening on server socket for 3 seconds. " <<
-						"Current client count: " << clients.size());
-					requestSocketWatcher.stop();
-					resumeSocketWatcherTimer.start();
-					endReached = true;
-				}
-			} else if (benchmarkPoint == BP_AFTER_ACCEPT) {
-				writeExact(fd,
-					"HTTP/1.1 200 OK\r\n"
-					"Status: 200 OK\r\n"
-					"Content-Type: text/html\r\n"
-					"Connection: close\r\n"
-					"\r\n"
-					"Benchmark point: after_accept\n");
-			} else {
-				ClientPtr client = boost::make_shared<Client>();
-				client->associate(this, fd);
-				clients.insert(make_pair((int) fd, client));
-				acceptedClients[count] = client;
-				count++;
-				RH_DEBUG(client, "New client accepted; new client count = " << clients.size());
-			}
-		}
-
-		for (unsigned int i = 0; i < count; i++) {
-			acceptedClients[i]->clientInput->readNow();
-		}
-
-		if (OXT_LIKELY(!clients.empty())) {
-			inactivityTimer.stop();
-		}
-	}
-
-
-	size_t onClientInputData(const ClientPtr &client, const StaticString &data) {
-		RH_LOG_EVENT(client, "onClientInputData");
-		if (!client->connected()) {
-			return 0;
-		}
-
-		if (data.empty()) {
-			onClientEof(client);
-			return 0;
-		} else {
-			return onClientRealData(client, data.data(), data.size());
-		}
-	}
-
-	size_t onClientRealData(const ClientPtr &client, const char *buf, size_t size) {
-		size_t consumed = 0;
-
-		while (consumed < size && client->connected() && client->clientInput->isStarted()) {
-			const char *data = buf + consumed;
-			size_t len       = size - consumed;
-			size_t locallyConsumed;
-
-			RH_TRACE(client, 3, "Processing client data: \"" << cEscapeString(StaticString(data, len)) << "\"");
-			switch (client->state) {
-			case Client::BEGIN_READING_CONNECT_PASSWORD:
-				locallyConsumed = state_beginReadingConnectPassword_onClientData(client, data, len);
-				break;
-			case Client::STILL_READING_CONNECT_PASSWORD:
-				locallyConsumed = state_stillReadingConnectPassword_onClientData(client, data, len);
-				break;
-			case Client::READING_HEADER:
-				locallyConsumed = state_readingHeader_onClientData(client, data, len);
-				break;
-			case Client::BUFFERING_REQUEST_BODY:
-				locallyConsumed = state_bufferingRequestBody_onClientData(client, data, len);
-				break;
-			case Client::FORWARDING_BODY_TO_APP:
-				locallyConsumed = state_forwardingBodyToApp_onClientData(client, data, len);
-				break;
-			default:
-				abort();
-			}
-
-			consumed += locallyConsumed;
-			RH_TRACE(client, 3, "Processed client data: consumed " << locallyConsumed << " bytes");
-			assert(consumed <= size);
-		}
-
-		return consumed;
-	}
-
-	void onClientEof(const ClientPtr &client) {
-		RH_LOG_EVENT(client, "onClientEof; client sent EOF");
-		switch (client->state) {
-		case Client::BUFFERING_REQUEST_BODY:
-			state_bufferingRequestBody_onClientEof(client);
-			break;
-		case Client::FORWARDING_BODY_TO_APP:
-			state_forwardingBodyToApp_onClientEof(client);
-			break;
-		default:
-			disconnect(client);
-			break;
-		}
-	}
-
-	void onClientInputError(const ClientPtr &client, const char *message, int errnoCode) {
-		RH_LOG_EVENT(client, "onClientInputError");
-		if (!client->connected()) {
-			return;
-		}
-
-		if (errnoCode == ECONNRESET) {
-			// We might as well treat ECONNRESET like an EOF.
-			// http://stackoverflow.com/questions/2974021/what-does-econnreset-mean-in-the-context-of-an-af-local-socket
-			RH_TRACE(client, 3, "Client socket ECONNRESET error; treating it as EOF");
-			onClientEof(client);
-		} else {
-			stringstream message;
-			message << "client socket read error: ";
-			message << strerror(errnoCode);
-			message << " (errno=" << errnoCode << ")";
-			disconnectWithError(client, message.str());
-		}
-	}
-
-
-	void onClientBodyBufferData(const ClientPtr &client, const char *data, size_t size, const FileBackedPipe::ConsumeCallback &consumed) {
-		RH_LOG_EVENT(client, "onClientBodyBufferData");
-		if (!client->connected()) {
-			return;
-		}
-
-		switch (client->state) {
-		case Client::FORWARDING_BODY_TO_APP:
-			state_forwardingBodyToApp_onClientBodyBufferData(client, data, size, consumed);
-			break;
-		default:
-			abort();
-		}
-	}
-
-	void onClientBodyBufferError(const ClientPtr &client, int errorCode) {
-		RH_LOG_EVENT(client, "onClientBodyBufferError");
-		if (!client->connected()) {
-			return;
-		}
-
-		stringstream message;
-		message << "client body buffer error: ";
-		message << strerror(errorCode);
-		message << " (errno=" << errorCode << ")";
-		disconnectWithError(client, message.str());
-	}
-
-	void onClientBodyBufferEnd(const ClientPtr &client) {
-		RH_LOG_EVENT(client, "onClientBodyBufferEnd");
-		if (!client->connected()) {
-			return;
-		}
-
-		switch (client->state) {
-		case Client::FORWARDING_BODY_TO_APP:
-			state_forwardingBodyToApp_onClientBodyBufferEnd(client);
-			break;
-		default:
-			abort();
-		}
-	}
-
-	void onClientBodyBufferCommit(const ClientPtr &client) {
-		RH_LOG_EVENT(client, "onClientBodyBufferCommit");
-		if (!client->connected()) {
-			return;
-		}
-
-		switch (client->state) {
-		case Client::BUFFERING_REQUEST_BODY:
-			state_bufferingRequestBody_onClientBodyBufferCommit(client);
-			break;
-		default:
-			abort();
-		}
-	}
-
-	void onAppOutputWritable(const ClientPtr &client) {
-		RH_LOG_EVENT(client, "onAppOutputWritable");
-		if (!client->connected()) {
-			return;
-		}
-
-		switch (client->state) {
-		case Client::SENDING_HEADER_TO_APP:
-			state_sendingHeaderToApp_onAppOutputWritable(client);
-			break;
-		case Client::FORWARDING_BODY_TO_APP:
-			state_forwardingBodyToApp_onAppOutputWritable(client);
-			break;
-		default:
-			abort();
-		}
-	}
-
-
-	void onTimeout(const ClientPtr &client) {
-		RH_LOG_EVENT(client, "onTimeout");
-		if (!client->connected()) {
-			return;
-		}
-
-		switch (client->state) {
-		case Client::BEGIN_READING_CONNECT_PASSWORD:
-		case Client::STILL_READING_CONNECT_PASSWORD:
-			disconnectWithError(client, "no connect password received within timeout");
-			break;
-		default:
-			disconnectWithError(client, "timeout");
-			break;
-		}
-	}
-
-
-	/*****************************************************
-	 * COMPONENT: client -> application plumbing
-	 *
-	 * The following code implements forwarding data from
-	 * the client to the application. Code is seperated
-	 * by client state.
-	 *****************************************************/
-
-
-	/******* State: BEGIN_READING_CONNECT_PASSWORD *******/
-
-	void checkConnectPassword(const ClientPtr &client, const char *data, unsigned int len) {
-		RH_TRACE(client, 3, "Given connect password: \"" << cEscapeString(StaticString(data, len)) << "\"");
-		if (constantTimeCompare(StaticString(data, len), options.requestSocketPassword)) {
-			RH_TRACE(client, 3, "Connect password is correct; reading header");
-			client->state = Client::READING_HEADER;
-			client->freeBufferedConnectPassword();
-			client->timeoutTimer.stop();
-
-			if (benchmarkPoint == BP_AFTER_CHECK_CONNECT_PASSWORD) {
-				writeSimpleResponse(client, "Benchmark point: after_check_connect_password\n");
-			}
-		} else {
-			disconnectWithError(client, "wrong connect password");
-		}
-	}
-
-	size_t state_beginReadingConnectPassword_onClientData(const ClientPtr &client, const char *data, size_t size) {
-		if (size >= options.requestSocketPassword.size()) {
-			checkConnectPassword(client, data, options.requestSocketPassword.size());
-			return options.requestSocketPassword.size();
-		} else {
-			client->bufferedConnectPassword.data = (char *) malloc(options.requestSocketPassword.size());
-			client->bufferedConnectPassword.alreadyRead = size;
-			memcpy(client->bufferedConnectPassword.data, data, size);
-			client->state = Client::STILL_READING_CONNECT_PASSWORD;
-			return size;
-		}
-	}
-
-
-	/******* State: STILL_READING_CONNECT_PASSWORD *******/
-
-	size_t state_stillReadingConnectPassword_onClientData(const ClientPtr &client, const char *data, size_t size) {
-		size_t consumed = std::min<size_t>(size,
-			options.requestSocketPassword.size() -
-				client->bufferedConnectPassword.alreadyRead);
-		memcpy(client->bufferedConnectPassword.data + client->bufferedConnectPassword.alreadyRead,
-			data, consumed);
-		client->bufferedConnectPassword.alreadyRead += consumed;
-		if (client->bufferedConnectPassword.alreadyRead == options.requestSocketPassword.size()) {
-			checkConnectPassword(client, client->bufferedConnectPassword.data,
-				options.requestSocketPassword.size());
-		}
-		return consumed;
-	}
-
-
-	/******* State: READING_HEADER *******/
-
-	bool modifyClientHeaders(const ClientPtr &client) {
-		ScgiRequestParser &parser = client->scgiParser;
-		ScgiRequestParser::HeaderMap &map = parser.getMap();
-		ScgiRequestParser::iterator it, end = map.end();
-		bool modified = false;
-
-		/* The Rack spec specifies that HTTP_CONTENT_LENGTH and HTTP_CONTENT_TYPE must
-		 * not exist and that their respective non-HTTP_ versions should exist instead.
-		 */
-
-		if ((it = map.find("HTTP_CONTENT_LENGTH")) != end) {
-			if (map.find("CONTENT_LENGTH") == end) {
-				map["CONTENT_LENGTH"] = it->second;
-				map.erase("HTTP_CONTENT_LENGTH");
-			} else {
-				map.erase(it);
-			}
-			modified = true;
-		}
-
-		if ((it = map.find("HTTP_CONTENT_TYPE")) != end) {
-			if (map.find("CONTENT_TYPE") == end) {
-				map["CONTENT_TYPE"] = it->second;
-				map.erase("HTTP_CONTENT_TYPE");
-			} else {
-				map.erase(it);
-			}
-			modified = true;
-		}
-
-		return modified;
-	}
-
-	void reportBadRequestAndDisconnect(const ClientPtr &client, const char *message) {
-		writeSimpleResponse(client, message, 400);
-		if (client->connected()) {
-			disconnectWithError(client, message);
-		}
-	}
-
-	void checkAndInternalizeRequestHeaders(const ClientPtr &client) {
-		ScgiRequestParser &parser = client->scgiParser;
-		StaticString requestMethod = parser.getHeader("REQUEST_METHOD");
-
-		if (requestMethod.empty()) {
-			reportBadRequestAndDisconnect(client, "Bad request (no request method given)");
-			return;
-		}
-
-		// Check Content-Length and Transfer-Encoding.
-		long long contentLength = getULongLongOption(client, "CONTENT_LENGTH");
-		StaticString transferEncoding = parser.getHeader("HTTP_TRANSFER_ENCODING");
-		if (contentLength != -1 && !transferEncoding.empty()) {
-			reportBadRequestAndDisconnect(client, "Bad request (request may not contain both Content-Length and Transfer-Encoding)");
-			return;
-		}
-		if (!transferEncoding.empty() && transferEncoding != "chunked") {
-			reportBadRequestAndDisconnect(client, "Bad request (only Transfer-Encoding chunked is supported)");
-			return;
-		}
-		// According to the HTTP/1.1 spec, Content-Length may not be 0.
-		// We could reject the request, but some important HTTP clients are broken
-		// (*cough* Ruby Net::HTTP *cough*) and fixing them is too much of
-		// a pain, so we choose support it.
-		if (contentLength == 0) {
-			contentLength = -1;
-			assert(transferEncoding.empty());
-		}
-
-		StaticString upgrade = parser.getHeader("HTTP_UPGRADE");
-		const bool requestIsGetOrHead = requestMethod == "GET" || requestMethod == "HEAD";
-		const bool requestBodyOffered = contentLength != -1 || !transferEncoding.empty();
-
-		// Reject requests that have a request body and an Upgrade header.
-		if (!requestIsGetOrHead && !upgrade.empty()) {
-			reportBadRequestAndDisconnect(client, "Bad request (Upgrade header is only allowed for non-GET and non-HEAD requests)");
-			return;
-		}
-
-		if (!requestBodyOffered) {
-			if (upgrade.empty()) {
-				client->requestBodyLength = 0;
-			} else {
-				client->requestBodyLength = -1;
-			}
-		} else {
-			client->requestBodyLength = contentLength;
-			client->requestIsChunked = !transferEncoding.empty();
-		}
-	}
-
-	static void fillPoolOption(const ClientPtr &client, StaticString &field, const StaticString &name) {
-		ScgiRequestParser::const_iterator it = client->scgiParser.getHeaderIterator(name);
-		if (it != client->scgiParser.end()) {
-			field = it->second;
-		}
-	}
-
-	static void fillPoolOption(const ClientPtr &client, bool &field, const StaticString &name) {
-		ScgiRequestParser::const_iterator it = client->scgiParser.getHeaderIterator(name);
-		if (it != client->scgiParser.end()) {
-			field = it->second == "true";
-		}
-	}
-
-	static void fillPoolOption(const ClientPtr &client, unsigned int &field, const StaticString &name) {
-		ScgiRequestParser::const_iterator it = client->scgiParser.getHeaderIterator(name);
-		if (it != client->scgiParser.end()) {
-			field = stringToUint(it->second);
-		}
-	}
-
-	static void fillPoolOption(const ClientPtr &client, unsigned long &field, const StaticString &name) {
-		ScgiRequestParser::const_iterator it = client->scgiParser.getHeaderIterator(name);
-		if (it != client->scgiParser.end()) {
-			field = stringToUint(it->second);
-		}
-	}
-
-	static void fillPoolOption(const ClientPtr &client, long &field, const StaticString &name) {
-		ScgiRequestParser::const_iterator it = client->scgiParser.getHeaderIterator(name);
-		if (it != client->scgiParser.end()) {
-			field = stringToInt(it->second);
-		}
-	}
-
-	static void fillPoolOptionSecToMsec(const ClientPtr &client, unsigned int &field, const StaticString &name) {
-		ScgiRequestParser::const_iterator it = client->scgiParser.getHeaderIterator(name);
-		if (it != client->scgiParser.end()) {
-			field = stringToUint(it->second) * 1000;
-		}
-	}
-
-	void fillPoolOptions(const ClientPtr &client) {
-		Options &options = client->options;
-		ScgiRequestParser &parser = client->scgiParser;
-		ScgiRequestParser::const_iterator it, end = client->scgiParser.end();
-
-		options = Options();
-
-		StaticString scriptName = parser.getHeader("SCRIPT_NAME");
-		StaticString appRoot = parser.getHeader("PASSENGER_APP_ROOT");
-		if (scriptName.empty()) {
-			if (appRoot.empty()) {
-				StaticString documentRoot = parser.getHeader("DOCUMENT_ROOT");
-				if (documentRoot.empty()) {
-					disconnectWithError(client, "no PASSENGER_APP_ROOT or DOCUMENT_ROOT headers set.");
-					return;
-				}
-				client->appRoot = extractDirName(documentRoot);
-				options.appRoot = client->appRoot;
-			} else {
-				options.appRoot = appRoot;
-			}
-		} else {
-			if (appRoot.empty()) {
-				client->appRoot = extractDirName(resolveSymlink(parser.getHeader("DOCUMENT_ROOT")));
-				options.appRoot = client->appRoot;
-			} else {
-				options.appRoot = appRoot;
-			}
-			options.baseURI = scriptName;
-		}
-
-		options.ruby = this->options.defaultRubyCommand;
-		options.logLevel = getLogLevel();
-		options.loggingAgentAddress = this->options.loggingAgentAddress;
-		options.loggingAgentUsername = "logging";
-		options.loggingAgentPassword = this->options.loggingAgentPassword;
-		options.defaultUser = this->options.defaultUser;
-		options.defaultGroup = this->options.defaultGroup;
-		fillPoolOption(client, options.appGroupName, "PASSENGER_APP_GROUP_NAME");
-		fillPoolOption(client, options.appType, "PASSENGER_APP_TYPE");
-		fillPoolOption(client, options.environment, "PASSENGER_APP_ENV");
-		fillPoolOption(client, options.ruby, "PASSENGER_RUBY");
-		fillPoolOption(client, options.python, "PASSENGER_PYTHON");
-		fillPoolOption(client, options.nodejs, "PASSENGER_NODEJS");
-		fillPoolOption(client, options.user, "PASSENGER_USER");
-		fillPoolOption(client, options.group, "PASSENGER_GROUP");
-		fillPoolOption(client, options.minProcesses, "PASSENGER_MIN_PROCESSES");
-		fillPoolOption(client, options.maxProcesses, "PASSENGER_MAX_PROCESSES");
-		fillPoolOption(client, options.maxRequests, "PASSENGER_MAX_REQUESTS");
-		fillPoolOption(client, options.spawnMethod, "PASSENGER_SPAWN_METHOD");
-		fillPoolOption(client, options.startCommand, "PASSENGER_START_COMMAND");
-		fillPoolOptionSecToMsec(client, options.startTimeout, "PASSENGER_START_TIMEOUT");
-		fillPoolOption(client, options.maxPreloaderIdleTime, "PASSENGER_MAX_PRELOADER_IDLE_TIME");
-		fillPoolOption(client, options.maxRequestQueueSize, "PASSENGER_MAX_REQUEST_QUEUE_SIZE");
-		fillPoolOption(client, options.statThrottleRate, "PASSENGER_STAT_THROTTLE_RATE");
-		fillPoolOption(client, options.restartDir, "PASSENGER_RESTART_DIR");
-		fillPoolOption(client, options.startupFile, "PASSENGER_STARTUP_FILE");
-		fillPoolOption(client, options.loadShellEnvvars, "PASSENGER_LOAD_SHELL_ENVVARS");
-		fillPoolOption(client, options.debugger, "PASSENGER_DEBUGGER");
-		fillPoolOption(client, options.raiseInternalError, "PASSENGER_RAISE_INTERNAL_ERROR");
-		setStickySessionId(client);
-		/******************/
-
-		for (it = client->scgiParser.begin(); it != end; it++) {
-			if (!startsWith(it->first, "PASSENGER_")
-			 && !startsWith(it->first, "HTTP_")
-			 && it->first != "PATH_INFO"
-			 && it->first != "SCRIPT_NAME"
-			 && it->first != "CONTENT_LENGTH"
-			 && it->first != "CONTENT_TYPE")
-			{
-				options.environmentVariables.push_back(*it);
-			}
-		}
-	}
-
-	void initializeUnionStation(const ClientPtr &client) {
-		if (getBoolOption(client, "UNION_STATION_SUPPORT", false)) {
-			Options &options = client->options;
-			ScgiRequestParser &parser = client->scgiParser;
-
-			StaticString key = parser.getHeader("UNION_STATION_KEY");
-			StaticString filters = parser.getHeader("UNION_STATION_FILTERS");
-			if (key.empty()) {
-				disconnectWithError(client, "header UNION_STATION_KEY must be set.");
-				return;
-			}
-
-			client->options.transaction = unionStationCore->newTransaction(
-				options.getAppGroupName(), "requests", key, filters);
-			if (!client->options.transaction->isNull()) {
-				client->options.analytics = true;
-				client->options.unionStationKey = key;
-			}
-
-			client->beginScopeLog(&client->scopeLogs.requestProcessing, "request processing");
-
-			StaticString staticRequestMethod = parser.getHeader("REQUEST_METHOD");
-			client->logMessage("Request method: " + staticRequestMethod);
-
-			StaticString staticRequestURI = parser.getHeader("REQUEST_URI");
-			if (!staticRequestURI.empty()) {
-				client->logMessage("URI: " + staticRequestURI);
-			} else {
-				string requestURI = parser.getHeader("SCRIPT_NAME");
-				requestURI.append(parser.getHeader("PATH_INFO"));
-				StaticString queryString = parser.getHeader("QUERY_STRING");
-				if (!queryString.empty()) {
-					requestURI.append("?");
-					requestURI.append(queryString);
-				}
-				client->logMessage("URI: " + requestURI);
-			}
-		}
-	}
-
-	void parseCookieHeader(const StaticString &header,
-		vector< pair<StaticString, StaticString> > &cookies) const
-	{
-		// See http://stackoverflow.com/questions/6108207/definite-guide-to-valid-cookie-values
-		// for syntax grammar.
-		vector<StaticString> parts;
-		vector<StaticString>::const_iterator it, it_end;
-
-		split(header, ';', parts);
-		cookies.reserve(parts.size());
-		it_end = parts.end();
-
-		for (it = parts.begin(); it != it_end; it++) {
-			const char *begin = it->data();
-			const char *end = it->data() + it->size();
-			const char *sep;
-
-			skipLeadingWhitespaces(&begin, end);
-			skipTrailingWhitespaces(begin, &end);
-
-			// Find the separator ('=').
-			sep = (const char *) memchr(begin, '=', end - begin);
-			if (sep != NULL) {
-				// Valid cookie. Otherwise, ignore it.
-				const char *nameEnd = sep;
-				const char *valueBegin = sep + 1;
-
-				skipTrailingWhitespaces(begin, &nameEnd);
-				skipLeadingWhitespaces(&valueBegin, end);
-
-				cookies.push_back(make_pair(
-					StaticString(begin, nameEnd - begin),
-					StaticString(valueBegin, end - valueBegin)
-				));
-			}
-		}
-	}
-
-	void setStickySessionId(const ClientPtr &client) {
-		ScgiRequestParser &parser = client->scgiParser;
-		if (parser.getHeader("PASSENGER_STICKY_SESSIONS") == "true") {
-			// TODO: This is not entirely correct. Clients MAY send multiple Cookie
-			// headers, although this is in practice extremely rare.
-			// http://stackoverflow.com/questions/16305814/are-multiple-cookie-headers-allowed-in-an-http-request
-			StaticString cookieHeader = parser.getHeader("HTTP_COOKIE");
-			StaticString cookieName = getStickySessionCookieName(client);
-			vector< pair<StaticString, StaticString> > cookies;
-			pair<StaticString, StaticString> cookie;
-
-			client->stickySession = true;
-			parseCookieHeader(cookieHeader, cookies);
-			foreach (cookie, cookies) {
-				if (cookie.first == cookieName) {
-					// This cookie matches the one we're looking for.
-					client->options.stickySessionId = stringToUint(cookie.second);
-					return;
-				}
-			}
-		}
-	}
-
-	StaticString getStickySessionCookieName(const ClientPtr &client) const {
-		StaticString value = client->scgiParser.getHeader("PASSENGER_STICKY_SESSIONS_COOKIE_NAME");
-		if (value.empty()) {
-			return StaticString(DEFAULT_STICKY_SESSIONS_COOKIE_NAME,
-				sizeof(DEFAULT_STICKY_SESSIONS_COOKIE_NAME) - 1);
-		} else {
-			return value;
-		}
-	}
-
-	size_t state_readingHeader_onClientData(const ClientPtr &client, const char *data, size_t size) {
-		ScgiRequestParser &parser = client->scgiParser;
-		size_t consumed = parser.feed(data, size);
-		if (!parser.acceptingInput()) {
-			if (parser.getState() == ScgiRequestParser::ERROR) {
-				if (parser.getErrorReason() == ScgiRequestParser::LIMIT_REACHED) {
-					disconnectWithError(client, "SCGI header too large");
-				} else {
-					disconnectWithError(client, "invalid SCGI header");
-				}
-				return consumed;
-			}
-
-			if (benchmarkPoint == BP_AFTER_PARSING_HEADER) {
-				writeSimpleResponse(client, "Benchmark point: after_parsing_header\n");
-				return consumed;
-			}
-
-			bool modified = modifyClientHeaders(client);
-			/* TODO: in case the headers are not modified, we only need to rebuild the header data
-			 * right now because the scgiParser buffer is invalidated as soon as onClientData exits.
-			 * We should figure out a way to not copy anything if we can do everything before
-			 * onClientData exits.
-			 */
-			parser.rebuildData(modified);
-
-			checkAndInternalizeRequestHeaders(client);
-			if (!client->connected()) {
-				return consumed;
-			}
-			fillPoolOptions(client);
-			if (!client->connected()) {
-				return consumed;
-			}
-			initializeUnionStation(client);
-			if (!client->connected()) {
-				return consumed;
-			}
-
-			if (getBoolOption(client, "PASSENGER_BUFFERING")) {
-				RH_TRACE(client, 3, "Valid SCGI header; buffering request body");
-				client->state = Client::BUFFERING_REQUEST_BODY;
-				client->requestBodyIsBuffered = true;
-				client->beginScopeLog(&client->scopeLogs.bufferingRequestBody, "buffering request body");
-				if (client->requestBodyLength == 0) {
-					client->clientInput->stop();
-					state_bufferingRequestBody_onClientEof(client);
-					return 0;
-				}
-			} else {
-				RH_TRACE(client, 3, "Valid SCGI header; not buffering request body; checking out session");
-				client->clientInput->stop();
-				checkoutSession(client);
-			}
-		}
-		return consumed;
-	}
-
-
-	/******* State: BUFFERING_REQUEST_BODY *******/
-
-	void state_bufferingRequestBody_verifyInvariants(const ClientPtr &client) const {
-		assert(client->requestBodyIsBuffered);
-		assert(!client->clientBodyBuffer->isStarted());
-	}
-
-	size_t state_bufferingRequestBody_onClientData(const ClientPtr &client, const char *data, size_t size) {
-		state_bufferingRequestBody_verifyInvariants(client);
-		assert(!client->clientBodyBuffer->isCommittingToDisk());
-
-		if (client->requestBodyLength >= 0) {
-			size = std::min<unsigned long long>(
-				size,
-				(unsigned long long) client->requestBodyLength - client->requestBodyAlreadyRead
-			);
-		}
-
-		if (!client->clientBodyBuffer->write(data, size)) {
-			// The pipe cannot write the data to disk quickly enough, so
-			// suspend reading from the client until the pipe is done.
-			client->backgroundOperations++; // TODO: figure out whether this is necessary
-			client->clientInput->stop();
-		}
-		client->requestBodyAlreadyRead += size;
-
-		RH_TRACE(client, 3, "Buffered " << size << " bytes of client body data; total=" <<
-			client->requestBodyAlreadyRead << ", content-length=" << client->requestBodyLength);
-		assert(client->requestBodyLength == -1 || client->requestBodyAlreadyRead <= (unsigned long long) client->requestBodyLength);
-
-		if (client->requestBodyLength >= 0 && client->requestBodyAlreadyRead == (unsigned long long) client->requestBodyLength) {
-			if (client->clientBodyBuffer->isCommittingToDisk()) {
-				RH_TRACE(client, 3, "Done buffering request body, but clientBodyBuffer not yet done committing data to disk; waiting until it's done");
-				client->checkoutSessionAfterCommit = true;
-			} else {
-				client->clientInput->stop();
-				state_bufferingRequestBody_onClientEof(client);
-			}
-		}
-
-		return size;
-	}
-
-	void state_bufferingRequestBody_onClientEof(const ClientPtr &client) {
-		state_bufferingRequestBody_verifyInvariants(client);
-
-		RH_TRACE(client, 3, "Done buffering request body; checking out session");
-		client->clientBodyBuffer->end();
-		client->endScopeLog(&client->scopeLogs.bufferingRequestBody);
-		checkoutSession(client);
-	}
-
-	void state_bufferingRequestBody_onClientBodyBufferCommit(const ClientPtr &client) {
-		// Now that the pipe has committed the data to disk
-		// resume reading from the client socket.
-		state_bufferingRequestBody_verifyInvariants(client);
-		assert(!client->clientInput->isStarted());
-		client->backgroundOperations--;
-		if (client->checkoutSessionAfterCommit) {
-			RH_TRACE(client, 3, "Done committing request body to disk");
-			state_bufferingRequestBody_onClientEof(client);
-		} else {
-			client->clientInput->start();
-		}
-	}
-
-
-	/******* State: CHECKING_OUT_SESSION *******/
-
-	void state_checkingOutSession_verifyInvariants(const ClientPtr &client) {
-		assert(!client->clientInput->isStarted());
-		assert(!client->clientBodyBuffer->isStarted());
-	}
-
-	void checkoutSession(const ClientPtr &client) {
-		if (benchmarkPoint != BP_BEFORE_CHECKOUT_SESSION) {
-			RH_TRACE(client, 2, "Checking out session: appRoot=" << client->options.appRoot);
-			client->state = Client::CHECKING_OUT_SESSION;
-			client->beginScopeLog(&client->scopeLogs.getFromPool, "get from pool");
-			pool->asyncGet(client->options, boost::bind(&RequestHandler::sessionCheckedOut,
-				this, client, _1, _2));
-			if (!client->sessionCheckedOut) {
-				client->backgroundOperations++;
-			}
-		} else {
-			writeSimpleResponse(client, "Benchmark point: before_checkout_session\n");
-		}
-	}
-
-	void sessionCheckedOut(ClientPtr client, const SessionPtr &session, const ExceptionPtr &e) {
-		if (!pthread_equal(pthread_self(), libev->getCurrentThread())) {
-			libev->runLater(boost::bind(&RequestHandler::sessionCheckedOut_real, this,
-				client, session, e));
-		} else {
-			sessionCheckedOut_real(client, session, e);
-		}
-	}
-
-	void sessionCheckedOut_real(ClientPtr client, const SessionPtr &session, const ExceptionPtr &e) {
-		RH_LOG_EVENT(client, "sessionCheckedOut");
-		if (!client->connected()) {
-			return;
-		}
-
-		state_checkingOutSession_verifyInvariants(client);
-		client->backgroundOperations--;
-		client->sessionCheckedOut = true;
-
-		if (e != NULL) {
-			client->endScopeLog(&client->scopeLogs.getFromPool, false);
-			{
-				boost::shared_ptr<RequestQueueFullException> e2 = dynamic_pointer_cast<RequestQueueFullException>(e);
-				if (e2 != NULL) {
-					writeRequestQueueFullExceptionErrorResponse(client);
-					return;
-				}
-			}
-			{
-				boost::shared_ptr<SpawnException> e2 = dynamic_pointer_cast<SpawnException>(e);
-				if (e2 != NULL) {
-					writeSpawnExceptionErrorResponse(client, e2);
-					return;
-				}
-			}
-			writeOtherExceptionErrorResponse(client, e);
-		} else {
-			RH_DEBUG(client, "Session checked out: pid=" << session->getPid() <<
-				", gupid=" << session->getGupid());
-			client->session = session;
-			initiateSession(client);
-		}
-	}
-
-	void writeRequestQueueFullExceptionErrorResponse(const ClientPtr &client) {
-		StaticString value = client->scgiParser.getHeader("PASSENGER_REQUEST_QUEUE_OVERFLOW_STATUS_CODE");
-		int requestQueueOverflowStatusCode = 503;
-		if (!value.empty()) {
-			requestQueueOverflowStatusCode = atoi(value.data());
-		}
-		writeSimpleResponse(client,
-			"<h1>This website is under heavy load</h1>"
-			"<p>We're sorry, too many people are accessing this website at the same "
-			"time. We're working on this problem. Please try again later.</p>",
-			requestQueueOverflowStatusCode);
-	}
-
-	void writeSpawnExceptionErrorResponse(const ClientPtr &client, const boost::shared_ptr<SpawnException> &e) {
-		RH_ERROR(client, "Cannot checkout session because a spawning error occurred. " <<
-			"The identifier of the error is " << e->get("error_id") << ". Please see earlier logs for " <<
-			"details about the error.");
-		writeErrorResponse(client, e->getErrorPage(), e.get());
-	}
-
-	void writeOtherExceptionErrorResponse(const ClientPtr &client, const ExceptionPtr &e) {
-		string typeName;
-		#ifdef CXX_ABI_API_AVAILABLE
-			int status;
-			char *tmp = abi::__cxa_demangle(typeid(*e).name(), 0, 0, &status);
-			if (tmp != NULL) {
-				typeName = tmp;
-				free(tmp);
-			} else {
-				typeName = typeid(*e).name();
-			}
-		#else
-			typeName = typeid(*e).name();
-		#endif
-
-		RH_WARN(client, "Cannot checkout session (exception type " <<
-			typeName << "): " << e->what());
-
-		string response = "An internal error occurred while trying to spawn the application.\n";
-		response.append("Exception type: ");
-		response.append(typeName);
-		response.append("\nError message: ");
-		response.append(e->what());
-		boost::shared_ptr<tracable_exception> e3 = dynamic_pointer_cast<tracable_exception>(e);
-		if (e3 != NULL) {
-			response.append("\nBacktrace:\n");
-			response.append(e3->backtrace());
-		}
-
-		writeErrorResponse(client, response);
-	}
-
-	void initiateSession(const ClientPtr &client) {
-		assert(client->state == Client::CHECKING_OUT_SESSION);
-		client->sessionCheckoutTry++;
-		try {
-			client->session->initiate();
-		} catch (const SystemException &e2) {
-			if (client->sessionCheckoutTry < 10) {
-				RH_DEBUG(client, "Error checking out session (" << e2.what() <<
-					"); retrying (attempt " << client->sessionCheckoutTry << ")");
-				client->sessionCheckedOut = false;
-				pool->asyncGet(client->options,
-					boost::bind(&RequestHandler::sessionCheckedOut,
-						this, client, _1, _2));
-				if (!client->sessionCheckedOut) {
-					client->backgroundOperations++;
-				}
-			} else {
-				string message = "could not initiate a session (";
-				message.append(e2.what());
-				message.append(")");
-				disconnectWithError(client, message);
-			}
-			return;
-		}
-
-		if (client->useUnionStation()) {
-			client->endScopeLog(&client->scopeLogs.getFromPool);
-			client->logMessage("Application PID: " +
-				toString(client->session->getPid()) +
-				" (GUPID: " + client->session->getGupid() + ")");
-			client->beginScopeLog(&client->scopeLogs.requestProxying, "request proxying");
-		}
-
-		RH_DEBUG(client, "Session initiated: fd=" << client->session->fd());
-		setNonBlocking(client->session->fd());
-		client->appInput->reset(libev.get(), client->session->fd());
-		client->appInput->start();
-		client->appOutputWatcher.set(libev->getLoop());
-		client->appOutputWatcher.set(client->session->fd(), ev::WRITE);
-		sendHeaderToApp(client);
-	}
-
-
-	/******* State: SENDING_HEADER_TO_APP *******/
-
-	void state_sendingHeaderToApp_verifyInvariants(const ClientPtr &client) {
-		assert(!client->clientInput->isStarted());
-		assert(!client->clientBodyBuffer->isStarted());
-	}
-
-	void sendHeaderToApp(const ClientPtr &client) {
-		assert(!client->clientInput->isStarted());
-		assert(!client->clientBodyBuffer->isStarted());
-
-		RH_TRACE(client, 2, "Sending headers to application");
-
-		if (client->session == NULL) {
-			disconnectWithError(client,
-				"Application sent EOF before we were able to send headers to it");
-		} else if (client->session->getProtocol() == "session") {
-			char sizeField[sizeof(boost::uint32_t)];
-			SmallVector<StaticString, 10> data;
-
-			data.push_back(StaticString(sizeField, sizeof(boost::uint32_t)));
-			data.push_back(client->scgiParser.getHeaderData());
-
-			data.push_back(makeStaticStringWithNull("PASSENGER_CONNECT_PASSWORD"));
-			data.push_back(makeStaticStringWithNull(client->session->getConnectPassword()));
-
-			if (client->options.analytics) {
-				data.push_back(makeStaticStringWithNull("PASSENGER_TXN_ID"));
-				data.push_back(makeStaticStringWithNull(client->options.transaction->getTxnId()));
-			}
-
-			boost::uint32_t dataSize = 0;
-			for (unsigned int i = 1; i < data.size(); i++) {
-				dataSize += (boost::uint32_t) data[i].size();
-			}
-			Uint32Message::generate(sizeField, dataSize);
-
-			ssize_t ret = gatheredWrite(client->session->fd(), &data[0],
-				data.size(), client->appOutputBuffer);
-			if (ret == -1 && errno != EAGAIN) {
-				disconnectWithAppSocketWriteError(client, errno);
-			} else if (!client->appOutputBuffer.empty()) {
-				client->state = Client::SENDING_HEADER_TO_APP;
-				client->appOutputWatcher.start();
-			} else {
-				sendBodyToApp(client);
-			}
-		} else {
-			assert(client->session->getProtocol() == "http_session");
-			const ScgiRequestParser &parser = client->scgiParser;
-			ScgiRequestParser::const_iterator it, end = parser.end();
-			string data;
-
-			data.reserve(parser.getHeaderData().size() + 128);
-			data.append(parser.getHeader("REQUEST_METHOD"));
-			data.append(" ");
-			data.append(parser.getHeader("REQUEST_URI"));
-			data.append(" HTTP/1.1\r\n");
-
-			for (it = parser.begin(); it != end; it++) {
-				if (startsWith(it->first, "HTTP_") && it->first != "HTTP_CONNECTION") {
-					string subheader = it->first.substr(sizeof("HTTP_") - 1);
-					string::size_type i;
-					for (i = 0; i < subheader.size(); i++) {
-						if (subheader[i] == '_') {
-							subheader[i] = '-';
-						} else if (i > 0 && subheader[i - 1] != '-') {
-							subheader[i] = tolower(subheader[i]);
-						}
-					}
-
-					data.append(subheader);
-					data.append(": ");
-					data.append(it->second);
-					data.append("\r\n");
-				}
-			}
-
-			StaticString connection = parser.getHeader("HTTP_CONNECTION");
-			if (regex_match(connection.data(), connection.data() + connection.size(),
-				upgradeHeaderRegex))
-			{
-				data.append("Connection: ");
-				data.append(connection.data(), connection.size());
-				data.append("\r\n");
-			} else {
-				data.append("Connection: close\r\n");
-			}
-
-			StaticString header = parser.getHeader("CONTENT_LENGTH");
-			if (!header.empty()) {
-				data.append("Content-Length: ");
-				data.append(header);
-				data.append("\r\n");
-			}
-
-			header = parser.getHeader("CONTENT_TYPE");
-			if (!header.empty()) {
-				data.append("Content-Type: ");
-				data.append(header);
-				data.append("\r\n");
-			}
-
-			header = parser.getHeader("HTTPS");
-			if (!header.empty()) {
-				data.append("X-Forwarded-Proto: https\r\n");
-			}
-
-			header = parser.getHeader("REMOTE_ADDR");
-			if (!header.empty()) {
-				data.append("X-Forwarded-For: ");
-				data.append(header);
-				data.append("\r\n");
-			}
-
-			if (client->options.analytics) {
-				data.append("Passenger-Txn-Id: ");
-				data.append(client->options.transaction->getTxnId());
-				data.append("\r\n");
-			}
-
-			P_TRACE(3, "Sending headers to application: " << data);
-			data.append("\r\n");
-
-			StaticString datas[] = { data };
-			ssize_t ret = gatheredWrite(client->session->fd(), datas,
-				1, client->appOutputBuffer);
-			if (ret == -1 && errno != EAGAIN) {
-				disconnectWithAppSocketWriteError(client, errno);
-				// TODO: what about other errors?
-			} else if (!client->appOutputBuffer.empty()) {
-				client->state = Client::SENDING_HEADER_TO_APP;
-				client->appOutputWatcher.start();
-			} else {
-				sendBodyToApp(client);
-			}
-		}
-	}
-
-	void state_sendingHeaderToApp_onAppOutputWritable(const ClientPtr &client) {
-		state_sendingHeaderToApp_verifyInvariants(client);
-
-		if (client->session == NULL) {
-			disconnectWithError(client,
-				"Application sent EOF before we were able to send headers to it");
-		} else {
-			ssize_t ret = gatheredWrite(client->session->fd(), NULL, 0, client->appOutputBuffer);
-			if (ret == -1) {
-				if (errno != EAGAIN && errno != EPIPE && errno != ECONNRESET) {
-					disconnectWithAppSocketWriteError(client, errno);
-				}
-				// TODO: what about other errors?
-			} else if (client->appOutputBuffer.empty()) {
-				client->appOutputWatcher.stop();
-				sendBodyToApp(client);
-			}
-		}
-	}
-
-
-	/******* State: FORWARDING_BODY_TO_APP *******/
-
-	void state_forwardingBodyToApp_verifyInvariants(const ClientPtr &client) const {
-		assert(client->state == Client::FORWARDING_BODY_TO_APP);
-	}
-
-	void sendBodyToApp(const ClientPtr &client) {
-		assert(client->appOutputBuffer.empty());
-		assert(!client->clientBodyBuffer->isStarted());
-		assert(!client->clientInput->isStarted());
-		assert(!client->appOutputWatcher.is_active());
-
-		RH_TRACE(client, 2, "Begin sending body to application");
-
-		client->state = Client::FORWARDING_BODY_TO_APP;
-		if (client->requestBodyIsBuffered) {
-			client->clientBodyBuffer->start();
-		} else if (client->requestBodyLength == 0) {
-			state_forwardingBodyToApp_onClientEof(client);
-		} else {
-			client->clientInput->start();
-		}
-	}
-
-
-	size_t state_forwardingBodyToApp_onClientData(const ClientPtr &client,
-		const char *data, size_t size)
-	{
-		state_forwardingBodyToApp_verifyInvariants(client);
-		assert(!client->requestBodyIsBuffered);
-
-		if (client->requestBodyLength >= 0) {
-			size = std::min<unsigned long long>(
-				size,
-				(unsigned long long) client->requestBodyLength - client->requestBodyAlreadyRead
-			);
-		}
-
-		RH_TRACE(client, 3, "Forwarding " << size << " bytes of client body data to application.");
-
-		if (client->session == NULL) {
-			RH_TRACE(client, 2, "Application had already sent EOF. Stop reading client input.");
-			client->clientInput->stop();
-			syscalls::shutdown(client->fd, SHUT_RD);
-			return 0;
-		}
-
-		ssize_t ret = syscalls::write(client->session->fd(), data, size);
-		int e = errno;
-		if (ret == -1) {
-			RH_TRACE(client, 3, "Could not write to application socket: " << strerror(e) << " (errno=" << e << ")");
-			if (e == EAGAIN) {
-				RH_TRACE(client, 3, "Waiting until the application socket is writable again.");
-				client->clientInput->stop();
-				client->appOutputWatcher.start();
-			} else if (e == EPIPE || e == ECONNRESET) {
-				// Client will be disconnected after response forwarding is done.
-				client->clientInput->stop();
-				syscalls::shutdown(client->fd, SHUT_RD);
-			} else {
-				disconnectWithAppSocketWriteError(client, e);
-			}
-			return 0;
-		} else {
-			client->requestBodyAlreadyRead += ret;
-
-			RH_TRACE(client, 3, "Managed to forward " << ret << " bytes; total=" <<
-				client->requestBodyAlreadyRead << ", content-length=" << client->requestBodyLength);
-			assert(client->requestBodyLength == -1 || client->requestBodyAlreadyRead <= (unsigned long long) client->requestBodyLength);
-			if (client->requestBodyLength >= 0 && client->requestBodyAlreadyRead == (unsigned long long) client->requestBodyLength) {
-				client->clientInput->stop();
-				state_forwardingBodyToApp_onClientEof(client);
-			}
-
-			return ret;
-		}
-	}
-
-	void state_forwardingBodyToApp_onClientEof(const ClientPtr &client) {
-		state_forwardingBodyToApp_verifyInvariants(client);
-		assert(!client->requestBodyIsBuffered);
-
-		RH_TRACE(client, 2, "End of (unbuffered) client body reached; done sending data to application");
-		client->clientInput->stop();
-		if (client->session != NULL && client->shouldHalfCloseWrite()) {
-			syscalls::shutdown(client->session->fd(), SHUT_WR);
-		}
-	}
-
-	void state_forwardingBodyToApp_onAppOutputWritable(const ClientPtr &client) {
-		state_forwardingBodyToApp_verifyInvariants(client);
-
-		RH_TRACE(client, 3, "Application socket became writable again.");
-		client->appOutputWatcher.stop();
-		if (client->requestBodyIsBuffered) {
-			assert(!client->clientBodyBuffer->isStarted());
-			client->clientBodyBuffer->start();
-		} else {
-			assert(!client->clientInput->isStarted());
-			client->clientInput->start();
-		}
-	}
-
-
-	void state_forwardingBodyToApp_onClientBodyBufferData(const ClientPtr &client,
-		const char *data, size_t size, const FileBackedPipe::ConsumeCallback &consumed)
-	{
-		state_forwardingBodyToApp_verifyInvariants(client);
-		assert(client->requestBodyIsBuffered);
-
-		RH_TRACE(client, 3, "Forwarding " << size << " bytes of buffered client body data to application.");
-
-		if (client->session == NULL) {
-			RH_TRACE(client, 2, "Application had already sent EOF. Stop reading client input.");
-			syscalls::shutdown(client->fd, SHUT_RD);
-			consumed(0, true);
-			return;
-		}
-
-		ssize_t ret = syscalls::write(client->session->fd(), data, size);
-		if (ret == -1) {
-			int e = errno;
-			RH_TRACE(client, 3, "Could not write to application socket: " << strerror(e) << " (errno=" << e << ")");
-			if (e == EAGAIN) {
-				RH_TRACE(client, 3, "Waiting until the application socket is writable again.");
-				client->appOutputWatcher.start();
-				consumed(0, true);
-			} else if (e == EPIPE || e == ECONNRESET) {
-				// Client will be disconnected after response forwarding is done.
-				syscalls::shutdown(client->fd, SHUT_RD);
-				consumed(0, true);
-			} else {
-				disconnectWithAppSocketWriteError(client, e);
-			}
-		} else {
-			RH_TRACE(client, 3, "Managed to forward " << ret << " bytes.");
-			consumed(ret, false);
-		}
-	}
-
-	void state_forwardingBodyToApp_onClientBodyBufferEnd(const ClientPtr &client) {
-		state_forwardingBodyToApp_verifyInvariants(client);
-		assert(client->requestBodyIsBuffered);
-
-		RH_TRACE(client, 2, "End of (buffered) client body reached; done sending data to application");
-		if (client->session != NULL && client->shouldHalfCloseWrite()) {
-			syscalls::shutdown(client->session->fd(), SHUT_WR);
-		}
-	}
-
-
-public:
-	// For unit testing purposes.
-	unsigned int connectPasswordTimeout; // milliseconds
-
-	BenchmarkPoint benchmarkPoint;
-
-	RequestHandler(const SafeLibevPtr &_libev,
-		const FileDescriptor &_requestSocket,
-		const PoolPtr &_pool,
-		const AgentOptions &_options)
-		: libev(_libev),
-		  requestSocket(_requestSocket),
-		  pool(_pool),
-		  options(_options),
-		  resourceLocator(_options.passengerRoot),
-		  upgradeHeaderRegex("(keep-alive, *)?upgrade(, *keep-alive)?",
-		      boost::regex::perl | boost::regex::icase),
-		  benchmarkPoint(getDefaultBenchmarkPoint())
-	{
-		accept4Available = true;
-		connectPasswordTimeout = 15000;
-		unionStationCore = pool->getUnionStationCore();
-
-		requestSocketWatcher.set(_requestSocket, ev::READ);
-		requestSocketWatcher.set(_libev->getLoop());
-		requestSocketWatcher.set<RequestHandler, &RequestHandler::onAcceptable>(this);
-		requestSocketWatcher.start();
-
-		resumeSocketWatcherTimer.set<RequestHandler, &RequestHandler::onResumeSocketWatcher>(this);
-		resumeSocketWatcherTimer.set(_libev->getLoop());
-		resumeSocketWatcherTimer.set(3, 3);
-	}
-
-	template<typename Stream>
-	void inspect(Stream &stream) const {
-		stream << clients.size() << " clients:\n";
-		HashMap<int, ClientPtr>::const_iterator it;
-		for (it = clients.begin(); it != clients.end(); it++) {
-			const ClientPtr &client = it->second;
-			stream << "  Client " << client->fd << ":\n";
-			client->inspect(stream);
-		}
-	}
-
-	void resetInactivityTime() {
-		libev->run(boost::bind(&RequestHandler::doResetInactivityTime, this));
-	}
-
-	unsigned long long inactivityTime() const {
-		unsigned long long result;
-		libev->run(boost::bind(&RequestHandler::getInactivityTime, this, &result));
-		return result;
+		return doc;
 	}
 };