passenger 5.0.21 → 5.0.22

data/src/agent/Core/ApplicationPool/BasicGroupInfo.h

@@ -46,7 +46,7 @@ class Group;
  *
  * Since Process and Session sometimes need to look up this basic group
  * information, this struct also serves to ensure that Process and Session do
- * not have a direct dependency on Group, but on GroupImmutableInfo instead.
+ * not have a direct dependency on Group, but on BasicGroupInfo instead.
  */
 class BasicGroupInfo {
 public:

data/src/agent/Core/ApplicationPool/BasicProcessInfo.h

@@ -92,6 +92,12 @@ public:
 		: process(_process),
 		  groupInfo(_groupInfo),
 		  pid(getJsonIntField(json, "pid"))
+		  // We initialize this in Process::initializeStickySessionId(),
+		  // called from Group::attach().
+		  // We should probably some day refactor this. The reason we do
+		  // it the way we do right now is because some day we want to be able
+		  // to attach external processes, so the best place to initialize this
+		  // information is in Group::attach().
 		  //stickySessionId(getJsonUintField(json, "sticky_session_id", 0))
 	{
 		StaticString gupid = getJsonStaticStringField(json, "gupid");

data/src/agent/Core/ApplicationPool/Common.h

@@ -39,7 +39,7 @@
 #include <Utils/VariantMap.h>
 #include <Core/ApplicationPool/Options.h>
 #include <Core/SpawningKit/Config.h>
-#include <Core/UnionStation/Core.h>
+#include <Core/UnionStation/Context.h>
 #include <Core/UnionStation/Transaction.h>
 
 namespace tut {

data/src/agent/Core/ApplicationPool/Group/OutOfBandWork.cpp

@@ -225,7 +225,7 @@ Group::spawnThreadOOBWRequest(GroupPtr self, ProcessPtr process) {
 		connection.fail = true;
 		ScopeGuard guard(boost::bind(&Socket::checkinConnection, socket, connection));
 
-		// This is copied from RequestHandler when it is sending data using the
+		// This is copied from Core::Controller when it is sending data using the
 		// "session" protocol.
 		char sizeField[sizeof(boost::uint32_t)];
 		SmallVector<StaticString, 10> data;

data/src/agent/Core/ApplicationPool/Group/ProcessListManagement.cpp

@@ -411,6 +411,10 @@ Group::attach(const ProcessPtr &process,
 	}
 
 	process->initializeStickySessionId(generateStickySessionId());
+	if (options.forceMaxConcurrentRequestsPerProcess != -1) {
+		process->forceMaxConcurrency(options.forceMaxConcurrentRequestsPerProcess);
+	}
+
 	P_DEBUG("Attaching process " << process->inspect());
 	addProcessToList(process, enabledProcesses);
 

data/src/agent/Core/ApplicationPool/Implementation.cpp

@@ -175,10 +175,10 @@ void processAndLogNewSpawnException(SpawnException &e, const Options &options,
 	char filename[PATH_MAX];
 	stringstream stream;
 
-	if (options.analytics && config->unionStationCore != NULL) {
+	if (options.analytics && config->unionStationContext != NULL) {
 		try {
 			UPDATE_TRACE_POINT();
-			transaction = config->unionStationCore->newTransaction(
+			transaction = config->unionStationContext->newTransaction(
 				options.getAppGroupName(),
 				"exceptions",
 				options.unionStationKey);

data/src/agent/Core/ApplicationPool/Options.h

@@ -36,7 +36,7 @@
 #include <ResourceLocator.h>
 #include <StaticString.h>
 #include <Utils.h>
-#include <Core/UnionStation/Core.h>
+#include <Core/UnionStation/Context.h>
 #include <Core/UnionStation/Transaction.h>
 
 namespace Passenger {
@@ -281,6 +281,15 @@ public:
 	 */
 	StaticString environmentVariables;
 
+	/**
+	 * If set to a value that isn't -1, makes Passenger ignore the application's
+	 * advertised socket concurrency, and believe that the concurrency should be
+	 * the given value.
+	 *
+	 * Defaults to -1.
+	 */
+	int forceMaxConcurrentRequestsPerProcess;
+
 	/** Whether debugger support should be enabled. */
 	bool debugger;
 
@@ -350,6 +359,12 @@ public:
 	 */
 	unsigned int maxRequestQueueSize;
 
+	/**
+	 * Whether websocket connections should be aborted on process shutdown
+	 * or restart.
+	 */
+	bool abortWebsocketsOnProcessShutdown;
+
 	/**
 	 * The Union Station key to use in case analytics logging is enabled.
 	 * It is used by Pool::collectAnalytics() and other administrative
@@ -461,6 +476,7 @@ public:
 		  ruby(DEFAULT_RUBY, sizeof(DEFAULT_RUBY) - 1),
 		  python(DEFAULT_PYTHON, sizeof(DEFAULT_PYTHON) - 1),
 		  nodejs(DEFAULT_NODEJS, sizeof(DEFAULT_NODEJS) - 1),
+		  forceMaxConcurrentRequestsPerProcess(-1),
 		  debugger(false),
 		  loadShellEnvvars(true),
 		  userSwitching(true),
@@ -472,6 +488,7 @@ public:
 		  maxPreloaderIdleTime(-1),
 		  maxOutOfBandWorkInstances(1),
 		  maxRequestQueueSize(100),
+		  abortWebsocketsOnProcessShutdown(true),
 
 		  stickySessionId(0),
 		  statThrottleRate(DEFAULT_STAT_THROTTLE_RATE),

data/src/agent/Core/ApplicationPool/Pool.h

@@ -405,7 +405,7 @@ public:
 
 	Context *getContext();
 	const SpawningKit::ConfigPtr &getSpawningKitConfig() const;
-	const UnionStation::CorePtr &getUnionStationCore() const;
+	const UnionStation::ContextPtr &getUnionStationContext() const;
 	const RandomGeneratorPtr &getRandomGenerator() const;
 
 

data/src/agent/Core/ApplicationPool/Pool/AnalyticsCollection.cpp

@@ -112,8 +112,8 @@ void
 Pool::prepareUnionStationProcessStateLogs(vector<UnionStationLogEntry> &logEntries,
 	const GroupPtr &group) const
 {
-	const UnionStation::CorePtr &unionStationCore = getUnionStationCore();
-	if (group->options.analytics && unionStationCore != NULL) {
+	const UnionStation::ContextPtr &unionStationContext = getUnionStationContext();
+	if (group->options.analytics && unionStationContext != NULL) {
 		logEntries.push_back(UnionStationLogEntry());
 		UnionStationLogEntry &entry = logEntries.back();
 		stringstream stream;
@@ -133,8 +133,8 @@ void
 Pool::prepareUnionStationSystemMetricsLogs(vector<UnionStationLogEntry> &logEntries,
 	const GroupPtr &group) const
 {
-	const UnionStation::CorePtr &unionStationCore = getUnionStationCore();
-	if (group->options.analytics && unionStationCore != NULL) {
+	const UnionStation::ContextPtr &unionStationContext = getUnionStationContext();
+	if (group->options.analytics && unionStationContext != NULL) {
 		logEntries.push_back(UnionStationLogEntry());
 		UnionStationLogEntry &entry = logEntries.back();
 		stringstream stream;
@@ -228,12 +228,12 @@ Pool::realCollectAnalytics() {
 		l.unlock();
 		UPDATE_TRACE_POINT();
 		if (!logEntries.empty()) {
-			const UnionStation::CorePtr &unionStationCore = getUnionStationCore();
+			const UnionStation::ContextPtr &unionStationContext = getUnionStationContext();
 			P_DEBUG("Sending process and system metrics to Union Station");
 			while (!logEntries.empty()) {
 				UnionStationLogEntry &entry = logEntries.back();
 				UnionStation::TransactionPtr transaction =
-					unionStationCore->newTransaction(
+					unionStationContext->newTransaction(
 						entry.groupName,
 						entry.category,
 						entry.key);

data/src/agent/Core/ApplicationPool/Pool/GeneralUtils.cpp

@@ -227,9 +227,9 @@ Pool::getSpawningKitConfig() const {
 	return context.getSpawningKitConfig();
 }
 
-const UnionStation::CorePtr &
-Pool::getUnionStationCore() const {
-	return getSpawningKitConfig()->unionStationCore;
+const UnionStation::ContextPtr &
+Pool::getUnionStationContext() const {
+	return getSpawningKitConfig()->unionStationContext;
 }
 
 const RandomGeneratorPtr &

data/src/agent/Core/ApplicationPool/Pool/InitializationAndShutdown.cpp

@@ -91,7 +91,7 @@ Pool::initDebugging() {
  * Should be called right after the agent has received
  * the message to exit gracefully. This will tell processes to
  * abort any long-running connections, e.g. WebSocket connections,
- * because the RequestHandler has to wait until all connections are
+ * because the Core::Controller has to wait until all connections are
  * finished before proceeding with shutdown.
  */
 void

data/src/agent/Core/ApplicationPool/Pool/Miscellaneous.cpp

@@ -25,6 +25,12 @@
  */
 #include <Core/ApplicationPool/Pool.h>
 
+/*************************************************************************
+ *
+ * Miscellaneous functions for ApplicationPool2::Pool
+ *
+ *************************************************************************/
+
 namespace Passenger {
 namespace ApplicationPool2 {
 

data/src/agent/Core/ApplicationPool/Process.h

@@ -293,7 +293,7 @@ private:
 			Socket *socket = &(*it);
 			if (socket->protocol == "session" || socket->protocol == "http_session") {
 				if (sessionSocketCount == MAX_SESSION_SOCKETS) {
-					throw RuntimeException("The process has many session sockets. "
+					throw RuntimeException("The process has too many session sockets. "
 						"A maximum of " + toString(MAX_SESSION_SOCKETS) + " is allowed");
 				}
 				sessionSockets[sessionSocketCount] = socket;
@@ -480,6 +480,11 @@ public:
 		info.stickySessionId = value;
 	}
 
+	void forceMaxConcurrency(int value) {
+		assert(value >= 0);
+		concurrency = value;
+	}
+
 	void shutdownNotRequired() {
 		requiresShutdown = false;
 	}

data/src/agent/Core/ApplicationPool/Socket.h

@@ -226,20 +226,17 @@ public:
 	int busyness() const {
 		/* Different sockets within a Process may have different
 		 * 'concurrency' values. We want:
-		 * - Process.sessionSockets to sort the sockets from least used to most used.
-		 * - to give sockets with concurrency == 0 more priority over sockets
-		 *   with concurrency > 0.
-		 * Therefore, we describe our busyness as a percentage of 'concurrency', with
-		 * the percentage value in [0..INT_MAX] instead of [0..1].
+		 * - the socket with the smallest busyness to be be picked for routing.
+		 * - to give sockets with concurrency == 0 more priority (in general)
+		 *   over sockets with concurrency > 0.
+		 * Therefore, in case of sockets with concurrency > 0, we describe our
+		 * busyness as a percentage of 'concurrency', with the percentage value
+		 * in [0..INT_MAX] instead of [0..1]. That way, the busyness value
+		 * of sockets with concurrency > 0 is usually higher than that of sockets
+		 * with concurrency == 0.
 		 */
 		if (concurrency == 0) {
-			// Allows Process.sessionSockets to give
-			// idle sockets more priority.
-			if (sessions == 0) {
-				return 0;
-			} else {
-				return 1;
-			}
+			return sessions;
 		} else {
 			return (int) (((long long) sessions * INT_MAX) / (double) concurrency);
 		}

data/src/agent/Core/Controller.h

@@ -0,0 +1,422 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2011-2015 Phusion Holding B.V.
+ *
+ *  "Passenger", "Phusion Passenger" and "Union Station" are registered
+ *  trademarks of Phusion Holding B.V.
+ *
+ *  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_CORE_CONTROLLER_H_
+#define _PASSENGER_CORE_CONTROLLER_H_
+
+
+//#define DEBUG_CC_EVENT_LOOP_BLOCKING
+
+#define CC_BENCHMARK_POINT(client, req, value) \
+	do { \
+		if (OXT_UNLIKELY(benchmarkMode == value)) { \
+			writeBenchmarkResponse(&client, &req); \
+			return; \
+		} \
+	} while (false)
+
+
+#include <boost/shared_ptr.hpp>
+#include <boost/make_shared.hpp>
+#include <boost/cstdint.hpp>
+#include <oxt/macros.hpp>
+#include <ev++.h>
+#include <ostream>
+
+#if defined(__GLIBCXX__) || defined(__APPLE__)
+	#include <cxxabi.h>
+	#define CXX_ABI_API_AVAILABLE
+#endif
+
+#include <sys/types.h>
+#include <sys/uio.h>
+#include <utility>
+#include <typeinfo>
+#include <cstdio>
+#include <cstdlib>
+#include <cstddef>
+#include <cassert>
+#include <cctype>
+
+#include <Logging.h>
+#include <MessageReadersWriters.h>
+#include <Constants.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 <StaticString.h>
+#include <Utils.h>
+#include <Utils/StrIntUtils.h>
+#include <Utils/IOUtils.h>
+#include <Utils/JsonUtils.h>
+#include <Utils/HttpConstants.h>
+#include <Utils/VariantMap.h>
+#include <Utils/Timer.h>
+#include <Core/ApplicationPool/ErrorRenderer.h>
+#include <Core/Controller/Client.h>
+#include <Core/Controller/AppResponse.h>
+#include <Core/Controller/TurboCaching.h>
+#include <Core/UnionStation/Context.h>
+
+namespace Passenger {
+
+using namespace std;
+using namespace boost;
+using namespace oxt;
+using namespace ApplicationPool2;
+
+
+namespace ServerKit {
+	extern const HashedStaticString HTTP_COOKIE;
+	extern const HashedStaticString HTTP_SET_COOKIE;
+}
+
+namespace Core {
+
+
+class Controller: public ServerKit::HttpServer<Controller, Client> {
+public:
+	enum BenchmarkMode {
+		BM_NONE,
+		BM_AFTER_ACCEPT,
+		BM_BEFORE_CHECKOUT,
+		BM_AFTER_CHECKOUT,
+		BM_RESPONSE_BEGIN,
+		BM_UNKNOWN
+	};
+
+private:
+	typedef ServerKit::HttpServer<Controller, 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;
+	unsigned int responseBufferHighWatermark;
+	BenchmarkMode benchmarkMode: 3;
+	bool singleAppMode: 1;
+	bool showVersionInHeader: 1;
+	bool stickySessions: 1;
+	bool gracefulExit: 1;
+
+	const VariantMap *agentsOptions;
+	psg_pool_t *stringPool;
+	StringKeyTable< boost::shared_ptr<Options> > poolOptionsCache;
+
+	StaticString defaultRuby;
+	StaticString ustRouterAddress;
+	StaticString ustRouterPassword;
+	StaticString defaultUser;
+	StaticString defaultGroup;
+	StaticString defaultServerName;
+	StaticString defaultServerPort;
+	StaticString serverSoftware;
+	StaticString defaultStickySessionsCookieName;
+	StaticString defaultVaryTurbocacheByCookie;
+
+	HashedStaticString PASSENGER_APP_GROUP_NAME;
+	HashedStaticString PASSENGER_ENV_VARS;
+	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>;
+	friend class ResponseCache<Request>;
+	struct ev_check checkWatcher;
+	TurboCaching<Request> turboCaching;
+
+	#ifdef DEBUG_CC_EVENT_LOOP_BLOCKING
+		struct ev_prepare prepareWatcher;
+		ev_tstamp timeBeforeBlocking;
+	#endif
+
+
+	/****** Stage: initiatelize request ******/
+
+	struct RequestAnalysis;
+
+	void initializeFlags(Client *client, Request *req, RequestAnalysis &analysis);
+	bool respondFromTurboCache(Client *client, Request *req);
+	void initializePoolOptions(Client *client, Request *req, RequestAnalysis &analysis);
+	void fillPoolOptionsFromAgentsOptions(Options &options);
+	static void fillPoolOption(Request *req, StaticString &field,
+		const HashedStaticString &name);
+	static void fillPoolOption(Request *req, int &field,
+		const HashedStaticString &name);
+	static void fillPoolOption(Request *req, bool &field,
+		const HashedStaticString &name);
+	static void fillPoolOption(Request *req, unsigned int &field,
+		const HashedStaticString &name);
+	static void fillPoolOption(Request *req, unsigned long &field,
+		const HashedStaticString &name);
+	static void fillPoolOption(Request *req, long &field,
+		const HashedStaticString &name);
+	static void fillPoolOptionSecToMsec(Request *req, unsigned int &field,
+		const HashedStaticString &name);
+	void createNewPoolOptions(Client *client, Request *req,
+		const HashedStaticString &appGroupName);
+	void initializeUnionStation(Client *client, Request *req, RequestAnalysis &analysis);
+	void setStickySessionId(Client *client, Request *req);
+	const LString *getStickySessionCookieName(Request *req);
+
+
+	/****** Stage: buffering body ******/
+
+	void beginBufferingBody(Client *client, Request *req);
+	Channel::Result whenBufferingBody_onRequestBody(Client *client, Request *req,
+		const MemoryKit::mbuf &buffer, int errcode);
+
+
+	/****** Stage: checkout session ******/
+
+	void checkoutSession(Client *client, Request *req);
+	static void sessionCheckedOut(const SessionPtr &session,
+		const ExceptionPtr &e, void *userData);
+	void sessionCheckedOutFromAnotherThread(Client *client, Request *req,
+		SessionPtr session, ExceptionPtr e);
+	void sessionCheckedOutFromEventLoopThread(Client *client, Request *req,
+		const SessionPtr &session, const ExceptionPtr &e);
+	void maybeSend100Continue(Client *client, Request *req);
+	void initiateSession(Client *client, Request *req);
+	static void checkoutSessionLater(Request *req);
+	void reportSessionCheckoutError(Client *client, Request *req,
+		const ExceptionPtr &e);
+	void writeRequestQueueFullExceptionErrorResponse(Client *client,
+		Request *req, const boost::shared_ptr<RequestQueueFullException> &e);
+	void writeSpawnExceptionErrorResponse(Client *client, Request *req,
+		const boost::shared_ptr<SpawnException> &e);
+	void writeOtherExceptionErrorResponse(Client *client, Request *req,
+		const ExceptionPtr &e);
+	void endRequestWithErrorResponse(Client **c, Request **r,
+		const StaticString &message, const SpawnException *e = NULL);
+	bool friendlyErrorPagesEnabled(Request *req);
+
+
+	/****** Stage: send request to application ******/
+
+	struct SessionProtocolWorkingState;
+	struct HttpHeaderConstructionCache;
+
+	void sendHeaderToApp(Client *client, Request *req);
+	void sendHeaderToAppWithSessionProtocol(Client *client, Request *req);
+	static void sendBodyToAppWhenAppSinkIdle(Channel *_channel, unsigned int size);
+	unsigned int determineHeaderSizeForSessionProtocol(Request *req,
+		SessionProtocolWorkingState &state, string delta_monotonic);
+	bool constructHeaderForSessionProtocol(Request *req, char * restrict buffer,
+		unsigned int &size, const SessionProtocolWorkingState &state, string delta_monotonic);
+	void sendHeaderToAppWithHttpProtocol(Client *client, Request *req);
+	bool constructHeaderBuffersForHttpProtocol(Request *req, struct iovec *buffers,
+		unsigned int maxbuffers, unsigned int & restrict_ref nbuffers,
+		unsigned int & restrict_ref dataSize, HttpHeaderConstructionCache &cache);
+	bool sendHeaderToAppWithHttpProtocolAndWritev(Request *req, ssize_t &bytesWritten,
+		HttpHeaderConstructionCache &cache);
+	void sendHeaderToAppWithHttpProtocolWithBuffering(Request *req, unsigned int offset,
+		HttpHeaderConstructionCache &cache);
+	void sendBodyToApp(Client *client, Request *req);
+	void halfCloseAppSink(Client *client, Request *req);
+	Channel::Result whenSendingRequest_onRequestBody(Client *client, Request *req,
+		const MemoryKit::mbuf &buffer, int errcode);
+	static void resumeRequestBodyChannelWhenAppSinkIdle(Channel *_channel,
+		unsigned int size);
+	void startBodyChannel(Client *client, Request *req);
+	void stopBodyChannel(Client *client, Request *req);
+	void logAppSocketWriteError(Client *client, int errcode);
+
+
+	/****** Stage: forward application response to client ******/
+
+	static Channel::Result _onAppSourceData(Channel *_channel,
+		const MemoryKit::mbuf &buffer, int errcode);
+	Channel::Result onAppSourceData(Client *client, Request *req,
+		const MemoryKit::mbuf &buffer, int errcode);
+	void onAppResponseBegin(Client *client, Request *req);
+	void prepareAppResponseCaching(Client *client, Request *req);
+	void onAppResponse100Continue(Client *client, Request *req);
+	bool constructHeaderBuffersForResponse(Request *req, struct iovec *buffers,
+		unsigned int maxbuffers, unsigned int & restrict_ref nbuffers,
+		unsigned int & restrict_ref dataSize,
+		unsigned int & restrict_ref nCacheableBuffers);
+	unsigned int constructDateHeaderBuffersForResponse(char *dateStr,
+		unsigned int bufsize);
+	bool sendResponseHeaderWithWritev(Client *client, Request *req,
+		ssize_t &bytesWritten);
+	void sendResponseHeaderWithBuffering(Client *client, Request *req,
+		unsigned int offset);
+	void logResponseHeaders(Client *client, Request *req, struct iovec *buffers,
+		unsigned int nbuffers, unsigned int dataSize);
+	void markHeaderBuffersForTurboCaching(Client *client, Request *req,
+		struct iovec *buffers, unsigned int nbuffers);
+	static ServerKit::HttpHeaderParser<AppResponse, ServerKit::HttpParseResponse>
+		createAppResponseHeaderParser(ServerKit::Context *ctx, Request *req);
+	static ServerKit::HttpChunkedBodyParser createAppResponseChunkedBodyParser(
+		Request *req);
+	static unsigned int formatAppResponseChunkedBodyParserLoggingPrefix(char *buf,
+		unsigned int bufsize, void *userData);
+	void prepareAppResponseChunkedBodyParsing(Client *client, Request *req);
+	void writeResponseAndMarkForTurboCaching(Client *client, Request *req,
+		const MemoryKit::mbuf &buffer);
+	void markResponsePartForTurboCaching(Client *client, Request *req,
+		const MemoryKit::mbuf &buffer);
+	void maybeThrottleAppSource(Client *client, Request *req);
+	static void _outputBuffersFlushed(FileBufferedChannel *_channel);
+	void outputBuffersFlushed(Client *client, Request *req);
+	static void _outputDataFlushed(FileBufferedChannel *_channel);
+	void outputDataFlushed(Client *client, Request *req);
+	void handleAppResponseBodyEnd(Client *client, Request *req);
+	OXT_FORCE_INLINE void keepAliveAppConnection(Client *client, Request *req);
+	void storeAppResponseInTurboCache(Client *client, Request *req);
+	void finalizeUnionStationWithSuccess(Client *client, Request *req);
+
+
+	/***** Hooks ******/
+
+	static Channel::Result onBodyBufferData(Channel *_channel,
+		const MemoryKit::mbuf &buffer, int errcode);
+	#ifdef DEBUG_CC_EVENT_LOOP_BLOCKING
+		static void onEventLoopPrepare(EV_P_ struct ev_prepare *w, int revents);
+	#endif
+	static void onEventLoopCheck(EV_P_ struct ev_check *w, int revents);
+
+
+	/****** Internal utility functions ******/
+
+	static TurboCaching<Request>::State getTurboCachingInitialState(
+		const VariantMap *agentsOptions);
+	void generateServerLogName(unsigned int number);
+	void disconnectWithClientSocketWriteError(Client **client, int e);
+	void disconnectWithAppSocketIncompleteResponseError(Client **client);
+	void disconnectWithAppSocketReadError(Client **client, int e);
+	void disconnectWithAppSocketWriteError(Client **client, int e);
+	void endRequestWithAppSocketIncompleteResponse(Client **client,
+		Request **req);
+	void endRequestWithAppSocketReadError(Client **client, Request **req,
+		int e);
+	void endRequestWithSimpleResponse(Client **c, Request **r,
+		const StaticString &body, int code = 200);
+	void endRequestAsBadGateway(Client **client, Request **req);
+	void writeBenchmarkResponse(Client **client, Request **req,
+		bool end = true);
+	bool getBoolOption(Request *req, const HashedStaticString &name,
+		bool defaultValue = false);
+	template<typename Number> static Number clamp(Number value,
+		Number min, Number max);
+	static void gatherBuffers(char * restrict dest, unsigned int size,
+		const struct iovec *buffers, unsigned int nbuffers);
+	static LString *resolveSymlink(const StaticString &path, psg_pool_t *pool);
+	void parseCookieHeader(psg_pool_t *pool, const LString *headerValue,
+		vector< pair<StaticString, StaticString> > &cookies) const;
+	#ifdef DEBUG_CC_EVENT_LOOP_BLOCKING
+		void reportLargeTimeDiff(Client *client, const char *name,
+			ev_tstamp fromTime, ev_tstamp toTime);
+	#endif
+
+
+protected:
+	/****** Stage: initiatelize request ******/
+
+	virtual void onRequestBegin(Client *client, Request *req);
+
+
+	/****** Hooks ******/
+
+	virtual void onClientAccepted(Client *client);
+	virtual void onRequestObjectCreated(Client *client, Request *req);
+	virtual void deinitializeClient(Client *client);
+	virtual void reinitializeRequest(Client *client, Request *req);
+	virtual void deinitializeRequest(Client *client, Request *req);
+	void reinitializeAppResponse(Client *client, Request *req);
+	void deinitializeAppResponse(Client *client, Request *req);
+	virtual Channel::Result onRequestBody(Client *client, Request *req,
+		const MemoryKit::mbuf &buffer, int errcode);
+	virtual bool shouldDisconnectClientOnShutdown(Client *client);
+	virtual bool supportsUpgrade(Client *client, Request *req);
+
+
+public:
+	ResourceLocator *resourceLocator;
+	PoolPtr appPool;
+	UnionStation::ContextPtr unionStationContext;
+
+
+	/****** Initialization and shutdown ******/
+
+	Controller(ServerKit::Context *context, const VariantMap *_agentsOptions,
+		unsigned int _threadNumber = 1);
+	~Controller();
+	void initialize();
+
+
+	/****** Hooks ******/
+
+	virtual unsigned int getClientName(const Client *client, char *buf, size_t size) const;
+	virtual StaticString getServerName() const;
+
+
+	/****** State inspection and configuration ******/
+
+	virtual Json::Value getConfigAsJson() const;
+	virtual void configure(const Json::Value &doc);
+	virtual Json::Value inspectStateAsJson() const;
+	virtual Json::Value inspectClientStateAsJson(const Client *client) const;
+	virtual Json::Value inspectRequestStateAsJson(const Request *req) const;
+
+
+	/****** Miscellaneous *******/
+
+	static BenchmarkMode parseBenchmarkMode(const StaticString mode);
+	void disconnectLongRunningConnections(const StaticString &gupid);
+};
+
+
+} // namespace Core
+} // namespace Passenger
+
+#endif /* _PASSENGER_CORE_CONTROLLER_H_ */