passenger 5.0.21 → 5.0.22

data/src/agent/Core/{RequestHandler → Controller}/Hooks.cpp

@@ -23,37 +23,78 @@
  *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  *  THE SOFTWARE.
  */
+#include <Core/Controller.h>
 
-// This file is included inside the RequestHandler class.
+/*************************************************************************
+ *
+ * Hook functions for Core::Controller. This pertains the hooks that the
+ * parent classes (ServerKit::HttpServer and ServerKit::Server) provide,
+ * as well as hooks by libraries such as libev.
+ *
+ *************************************************************************/
 
-public:
+namespace Passenger {
+namespace Core {
 
-virtual unsigned int getClientName(const Client *client, char *buf, size_t size) const {
-	char *pos = buf;
-	const char *end = buf + size - 1;
-	// WARNING: If you change the format, be sure to change
-	// ApiServer::extractThreadNumberFromClientName() too.
-	pos += uintToString(threadNumber, pos, end - pos);
-	pos = appendData(pos, end, "-", 1);
-	pos += uintToString(client->number, pos, end - pos);
-	*pos = '\0';
-	return pos - buf;
+using namespace std;
+using namespace boost;
+
+
+/****************************
+ *
+ * Private methods
+ *
+ ****************************/
+
+
+ServerKit::Channel::Result
+Controller::onBodyBufferData(Channel *_channel, const MemoryKit::mbuf &buffer, int errcode) {
+	FileBufferedChannel *channel = reinterpret_cast<FileBufferedChannel *>(_channel);
+	Request *req = static_cast<Request *>(static_cast<
+		ServerKit::BaseHttpRequest *>(channel->getHooks()->userData));
+	Client *client = static_cast<Client *>(req->client);
+	Controller *self = static_cast<Controller *>(getServerFromClient(client));
+	SKC_LOG_EVENT_FROM_STATIC(self, Controller, client, "onBodyBufferData");
+
+	assert(req->requestBodyBuffering);
+	return self->whenSendingRequest_onRequestBody(client, req, buffer, errcode);
 }
 
-virtual StaticString getServerName() const {
-	return serverLogName;
+#ifdef DEBUG_CC_EVENT_LOOP_BLOCKING
+	void
+	Controller::onEventLoopPrepare(EV_P_ struct ev_prepare *w, int revents) {
+		Controller *self = static_cast<Controller *>(w->data);
+		ev_now_update(EV_A);
+		self->timeBeforeBlocking = ev_now(EV_A);
+	}
+#endif
+
+void
+Controller::onEventLoopCheck(EV_P_ struct ev_check *w, int revents) {
+	Controller *self = static_cast<Controller *>(w->data);
+	self->turboCaching.updateState(ev_now(EV_A));
+	#ifdef DEBUG_CC_EVENT_LOOP_BLOCKING
+		self->reportLargeTimeDiff(NULL, "Event loop slept",
+			self->timeBeforeBlocking, ev_now(EV_A));
+	#endif
 }
 
-protected:
 
-virtual void
-onClientAccepted(Client *client) {
+/****************************
+ *
+ * Protected methods
+ *
+ ****************************/
+
+
+void
+Controller::onClientAccepted(Client *client) {
 	ParentClass::onClientAccepted(client);
 	client->connectedAt = ev_now(getLoop());
 }
 
-virtual void
-onRequestObjectCreated(Client *client, Request *req) {
+void
+Controller::onRequestObjectCreated(Client *client, Request *req) {
 	ParentClass::onRequestObjectCreated(client, req);
 
 	req->appSink.setContext(getContext());
@@ -68,17 +109,19 @@ onRequestObjectCreated(Client *client, Request *req) {
 	req->bodyBuffer.setDataCallback(onBodyBufferData);
 }
 
-virtual void deinitializeClient(Client *client) {
+void
+Controller::deinitializeClient(Client *client) {
 	ParentClass::deinitializeClient(client);
 	client->output.setBuffersFlushedCallback(NULL);
 	client->output.setDataFlushedCallback(getClientOutputDataFlushedCallback());
 }
 
-virtual void reinitializeRequest(Client *client, Request *req) {
+void
+Controller::reinitializeRequest(Client *client, Request *req) {
 	ParentClass::reinitializeRequest(client, req);
 
-	// bodyBuffer is initialized in RequestHandler::beginBufferingBody().
-	// appSink and appSource are initialized in RequestHandler::checkoutSession().
+	// bodyBuffer is initialized in Controller::beginBufferingBody().
+	// appSink and appSource are initialized in Controller::checkoutSession().
 
 	req->startedAt = 0;
 	req->state = Request::ANALYZING_REQUEST;
@@ -98,7 +141,7 @@ virtual void reinitializeRequest(Client *client, Request *req) {
 	req->varyCookie = NULL;
 	req->envvars = NULL;
 
-	#ifdef DEBUG_RH_EVENT_LOOP_BLOCKING
+	#ifdef DEBUG_CC_EVENT_LOOP_BLOCKING
 		req->timedAppPoolGet = false;
 		req->timeBeforeAccessingApplicationPool = 0;
 		req->timeOnRequestHeaderSent = 0;
@@ -108,12 +151,13 @@ virtual void reinitializeRequest(Client *client, Request *req) {
 	/***************/
 }
 
-virtual void deinitializeRequest(Client *client, Request *req) {
+void
+Controller::deinitializeRequest(Client *client, Request *req) {
 	req->session.reset();
 
-	req->endStopwatchLog(&req->stopwatchLogs.requestProxying, false);
 	req->endStopwatchLog(&req->stopwatchLogs.getFromPool, false);
 	req->endStopwatchLog(&req->stopwatchLogs.bufferingRequestBody, false);
+	req->endStopwatchLog(&req->stopwatchLogs.requestProxying, false);
 	req->endStopwatchLog(&req->stopwatchLogs.requestProcessing, false);
 
 	req->options.transaction.reset();
@@ -133,7 +177,8 @@ virtual void deinitializeRequest(Client *client, Request *req) {
 	ParentClass::deinitializeRequest(client, req);
 }
 
-void reinitializeAppResponse(Client *client, Request *req) {
+void
+Controller::reinitializeAppResponse(Client *client, Request *req) {
 	AppResponse *resp = &req->appResponse;
 
 	req->appResponseInitialized = true;
@@ -160,7 +205,8 @@ void reinitializeAppResponse(Client *client, Request *req) {
 	psg_lstr_init(&resp->bodyCacheBuffer);
 }
 
-void deinitializeAppResponse(Client *client, Request *req) {
+void
+Controller::deinitializeAppResponse(Client *client, Request *req) {
 	AppResponse *resp = &req->appResponse;
 
 	req->appResponseInitialized = false;
@@ -197,8 +243,8 @@ void deinitializeAppResponse(Client *client, Request *req) {
 	psg_lstr_deinit(&resp->bodyCacheBuffer);
 }
 
-virtual Channel::Result
-onRequestBody(Client *client, Request *req, const MemoryKit::mbuf &buffer,
+ServerKit::Channel::Result
+Controller::onRequestBody(Client *client, Request *req, const MemoryKit::mbuf &buffer,
 	int errcode)
 {
 	switch (req->state) {
@@ -212,41 +258,42 @@ onRequestBody(Client *client, Request *req, const MemoryKit::mbuf &buffer,
 	}
 }
 
-virtual bool
-shouldDisconnectClientOnShutdown(Client *client) {
+bool
+Controller::shouldDisconnectClientOnShutdown(Client *client) {
 	return ParentClass::shouldDisconnectClientOnShutdown(client) || !gracefulExit;
 }
 
-private:
+bool
+Controller::supportsUpgrade(Client *client, Request *req) {
+	return true;
+}
 
-static Channel::Result
-onBodyBufferData(Channel *_channel, const MemoryKit::mbuf &buffer, int errcode) {
-	FileBufferedChannel *channel = reinterpret_cast<FileBufferedChannel *>(_channel);
-	Request *req = static_cast<Request *>(static_cast<
-		ServerKit::BaseHttpRequest *>(channel->getHooks()->userData));
-	Client *client = static_cast<Client *>(req->client);
-	RequestHandler *self = static_cast<RequestHandler *>(getServerFromClient(client));
-	SKC_LOG_EVENT_FROM_STATIC(self, RequestHandler, client, "onBodyBufferData");
 
-	assert(req->requestBodyBuffering);
-	return self->whenSendingRequest_onRequestBody(client, req, buffer, errcode);
-}
+/****************************
+ *
+ * Public methods
+ *
+ ****************************/
 
-#ifdef DEBUG_RH_EVENT_LOOP_BLOCKING
-	static void
-	onEventLoopPrepare(EV_P_ struct ev_prepare *w, int revents) {
-		RequestHandler *self = static_cast<RequestHandler *>(w->data);
-		ev_now_update(EV_A);
-		self->timeBeforeBlocking = ev_now(EV_A);
-	}
-#endif
 
-static void
-onEventLoopCheck(EV_P_ struct ev_check *w, int revents) {
-	RequestHandler *self = static_cast<RequestHandler *>(w->data);
-	self->turboCaching.updateState(ev_now(EV_A));
-	#ifdef DEBUG_RH_EVENT_LOOP_BLOCKING
-		self->reportLargeTimeDiff(NULL, "Event loop slept",
-			self->timeBeforeBlocking, ev_now(EV_A));
-	#endif
+unsigned int
+Controller::getClientName(const Client *client, char *buf, size_t size) const {
+	char *pos = buf;
+	const char *end = buf + size - 1;
+	// WARNING: If you change the format, be sure to change
+	// ApiServer::extractThreadNumberFromClientName() too.
+	pos += uintToString(threadNumber, pos, end - pos);
+	pos = appendData(pos, end, "-", 1);
+	pos += uintToString(client->number, pos, end - pos);
+	*pos = '\0';
+	return pos - buf;
 }
+
+StaticString
+Controller::getServerName() const {
+	return serverLogName;
+}
+
+
+} // namespace Core
+} // namespace Passenger

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

@@ -0,0 +1,38 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 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.
+ */
+
+#include <Core/Controller.h>
+#include <Core/Controller/InitRequest.cpp>
+#include <Core/Controller/BufferBody.cpp>
+#include <Core/Controller/CheckoutSession.cpp>
+#include <Core/Controller/SendRequest.cpp>
+#include <Core/Controller/ForwardResponse.cpp>
+#include <Core/Controller/Hooks.cpp>
+#include <Core/Controller/InitializationAndShutdown.cpp>
+#include <Core/Controller/InternalUtils.cpp>
+#include <Core/Controller/Miscellaneous.cpp>
+#include <Core/Controller/StateInspectionAndConfiguration.cpp>
+

data/src/agent/Core/{RequestHandler → Controller}/InitRequest.cpp

@@ -23,76 +23,38 @@
  *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  *  THE SOFTWARE.
  */
+#include <Core/Controller.h>
 
-// This file is included inside the RequestHandler class.
-
-protected:
+/*************************************************************************
+ *
+ * Implements Core::Controller methods pertaining the initialization
+ * of a request.
+ *
+ *************************************************************************/
 
-struct RequestAnalysis {
-	const LString *flags;
-	ServerKit::HeaderTable::Cell *appGroupNameCell;
-	bool unionStationSupport;
-};
+namespace Passenger {
+namespace Core {
 
-virtual void
-onRequestBegin(Client *client, Request *req) {
-	ParentClass::onRequestBegin(client, req);
+using namespace std;
+using namespace boost;
 
-	RH_BENCHMARK_POINT(client, req, BM_AFTER_ACCEPT);
 
-	{
-		// Perform hash table operations as close to header parsing as possible,
-		// and localize them as much as possible, for better CPU caching.
-		RequestAnalysis analysis;
-		analysis.flags = req->secureHeaders.lookup(FLAGS);
-		analysis.appGroupNameCell = singleAppMode
-			? NULL
-			: req->secureHeaders.lookupCell(PASSENGER_APP_GROUP_NAME);
-		analysis.unionStationSupport = unionStationCore != NULL
-			&& getBoolOption(req, UNION_STATION_SUPPORT, false);
-		req->stickySession = getBoolOption(req, PASSENGER_STICKY_SESSIONS,
-			this->stickySessions);
-		req->host = req->headers.lookup(HTTP_HOST);
-
-		/***************/
-		/***************/
-
-		SKC_TRACE(client, 2, "Initiating request");
-		req->startedAt = ev_now(getLoop());
-		req->bodyChannel.stop();
-
-		initializeFlags(client, req, analysis);
-		if (respondFromTurboCache(client, req)) {
-			return;
-		}
-		initializePoolOptions(client, req, analysis);
-		if (req->ended()) {
-			return;
-		}
-		initializeUnionStation(client, req, analysis);
-		if (req->ended()) {
-			return;
-		}
-		setStickySessionId(client, req);
-	}
+/****************************
+ *
+ * Private methods
+ *
+ ****************************/
 
-	if (!req->hasBody() || !req->requestBodyBuffering) {
-		req->requestBodyBuffering = false;
-		checkoutSession(client, req);
-	} else {
-		beginBufferingBody(client, req);
-	}
-}
 
-virtual bool
-supportsUpgrade(Client *client, Request *req) {
-	return true;
-}
+struct Controller::RequestAnalysis {
+	const LString *flags;
+	ServerKit::HeaderTable::Cell *appGroupNameCell;
+	bool unionStationSupport;
+};
 
-private:
 
 void
-initializeFlags(Client *client, Request *req, RequestAnalysis &analysis) {
+Controller::initializeFlags(Client *client, Request *req, RequestAnalysis &analysis) {
 	if (analysis.flags != NULL) {
 		const LString::Part *part = analysis.flags->start;
 		while (part != NULL) {
@@ -138,7 +100,7 @@ initializeFlags(Client *client, Request *req, RequestAnalysis &analysis) {
 }
 
 bool
-respondFromTurboCache(Client *client, Request *req) {
+Controller::respondFromTurboCache(Client *client, Request *req) {
 	if (!turboCaching.isEnabled() || !turboCaching.responseCache.prepareRequest(this, req)) {
 		return false;
 	}
@@ -171,7 +133,7 @@ respondFromTurboCache(Client *client, Request *req) {
 }
 
 void
-initializePoolOptions(Client *client, Request *req, RequestAnalysis &analysis) {
+Controller::initializePoolOptions(Client *client, Request *req, RequestAnalysis &analysis) {
 	boost::shared_ptr<Options> *options;
 
 	if (singleAppMode) {
@@ -215,7 +177,7 @@ initializePoolOptions(Client *client, Request *req, RequestAnalysis &analysis) {
 }
 
 void
-fillPoolOptionsFromAgentsOptions(Options &options) {
+Controller::fillPoolOptionsFromAgentsOptions(Options &options) {
 	options.ruby = defaultRuby;
 	if (agentsOptions->has("default_nodejs")) {
 		options.nodejs = agentsOptions->get("default_nodejs");
@@ -242,6 +204,9 @@ fillPoolOptionsFromAgentsOptions(Options &options) {
 	}
 	options.minProcesses = agentsOptions->getInt("min_instances");
 	options.maxPreloaderIdleTime = agentsOptions->getInt("max_preloader_idle_time");
+	options.maxRequestQueueSize = agentsOptions->getInt("max_request_queue_size");
+	options.abortWebsocketsOnProcessShutdown = agentsOptions->getBool("abort_websockets_on_process_shutdown");
+	options.forceMaxConcurrentRequestsPerProcess = agentsOptions->getInt("force_max_concurrent_requests_per_process");
 	options.spawnMethod = agentsOptions->get("spawn_method");
 	options.loadShellEnvvars = agentsOptions->getBool("load_shell_envvars");
 	options.statThrottleRate = statThrottleRate;
@@ -249,8 +214,10 @@ fillPoolOptionsFromAgentsOptions(Options &options) {
 	/******************************/
 }
 
-static void
-fillPoolOption(Request *req, StaticString &field, const HashedStaticString &name) {
+void
+Controller::fillPoolOption(Request *req, StaticString &field,
+	const HashedStaticString &name)
+{
 	const LString *value = req->secureHeaders.lookup(name);
 	if (value != NULL && value->size > 0) {
 		value = psg_lstr_make_contiguous(value, req->pool);
@@ -258,16 +225,31 @@ fillPoolOption(Request *req, StaticString &field, const HashedStaticString &name
 	}
 }
 
-static void
-fillPoolOption(Request *req, bool &field, const HashedStaticString &name) {
+void
+Controller::fillPoolOption(Request *req, bool &field,
+	const HashedStaticString &name)
+{
 	const LString *value = req->secureHeaders.lookup(name);
 	if (value != NULL && value->size > 0) {
 		field = psg_lstr_first_byte(value) == 't';
 	}
 }
 
-static void
-fillPoolOption(Request *req, unsigned int &field, const HashedStaticString &name) {
+void
+Controller::fillPoolOption(Request *req, int &field,
+	const HashedStaticString &name)
+{
+	const LString *value = req->secureHeaders.lookup(name);
+	if (value != NULL && value->size > 0) {
+		value = psg_lstr_make_contiguous(value, req->pool);
+		field = stringToInt(StaticString(value->start->data, value->size));
+	}
+}
+
+void
+Controller::fillPoolOption(Request *req, unsigned int &field,
+	const HashedStaticString &name)
+{
 	const LString *value = req->secureHeaders.lookup(name);
 	if (value != NULL && value->size > 0) {
 		value = psg_lstr_make_contiguous(value, req->pool);
@@ -275,8 +257,10 @@ fillPoolOption(Request *req, unsigned int &field, const HashedStaticString &name
 	}
 }
 
-static void
-fillPoolOption(Request *req, unsigned long &field, const HashedStaticString &name) {
+void
+Controller::fillPoolOption(Request *req, unsigned long &field,
+	const HashedStaticString &name)
+{
 	const LString *value = req->secureHeaders.lookup(name);
 	if (value != NULL && value->size > 0) {
 		value = psg_lstr_make_contiguous(value, req->pool);
@@ -284,8 +268,10 @@ fillPoolOption(Request *req, unsigned long &field, const HashedStaticString &nam
 	}
 }
 
-static void
-fillPoolOption(Request *req, long &field, const HashedStaticString &name) {
+void
+Controller::fillPoolOption(Request *req, long &field,
+	const HashedStaticString &name)
+{
 	const LString *value = req->secureHeaders.lookup(name);
 	if (value != NULL && value->size > 0) {
 		value = psg_lstr_make_contiguous(value, req->pool);
@@ -293,8 +279,10 @@ fillPoolOption(Request *req, long &field, const HashedStaticString &name) {
 	}
 }
 
-static void
-fillPoolOptionSecToMsec(Request *req, unsigned int &field, const HashedStaticString &name) {
+void
+Controller::fillPoolOptionSecToMsec(Request *req, unsigned int &field,
+	const HashedStaticString &name)
+{
 	const LString *value = req->secureHeaders.lookup(name);
 	if (value != NULL && value->size > 0) {
 		value = psg_lstr_make_contiguous(value, req->pool);
@@ -303,7 +291,9 @@ fillPoolOptionSecToMsec(Request *req, unsigned int &field, const HashedStaticStr
 }
 
 void
-createNewPoolOptions(Client *client, Request *req, const HashedStaticString &appGroupName) {
+Controller::createNewPoolOptions(Client *client, Request *req,
+	const HashedStaticString &appGroupName)
+{
 	ServerKit::HeaderTable &secureHeaders = req->secureHeaders;
 	Options &options = req->options;
 
@@ -383,6 +373,8 @@ createNewPoolOptions(Client *client, Request *req, const HashedStaticString &app
 	fillPoolOptionSecToMsec(req, options.startTimeout, "!~PASSENGER_START_TIMEOUT");
 	fillPoolOption(req, options.maxPreloaderIdleTime, "!~PASSENGER_MAX_PRELOADER_IDLE_TIME");
 	fillPoolOption(req, options.maxRequestQueueSize, "!~PASSENGER_MAX_REQUEST_QUEUE_SIZE");
+	fillPoolOption(req, options.abortWebsocketsOnProcessShutdown, "!~PASSENGER_ABORT_WEBSOCKETS_ON_PROCESS_SHUTDOWN");
+	fillPoolOption(req, options.forceMaxConcurrentRequestsPerProcess, "!~PASSENGER_FORCE_MAX_CONCURRENT_REQUESTS_PER_PROCESS");
 	fillPoolOption(req, options.restartDir, "!~PASSENGER_RESTART_DIR");
 	fillPoolOption(req, options.startupFile, "!~PASSENGER_STARTUP_FILE");
 	fillPoolOption(req, options.loadShellEnvvars, "!~PASSENGER_LOAD_SHELL_ENVVARS");
@@ -397,7 +389,7 @@ createNewPoolOptions(Client *client, Request *req, const HashedStaticString &app
 }
 
 void
-initializeUnionStation(Client *client, Request *req, RequestAnalysis &analysis) {
+Controller::initializeUnionStation(Client *client, Request *req, RequestAnalysis &analysis) {
 	if (analysis.unionStationSupport) {
 		Options &options = req->options;
 		ServerKit::HeaderTable &headers = req->secureHeaders;
@@ -414,7 +406,7 @@ initializeUnionStation(Client *client, Request *req, RequestAnalysis &analysis)
 			filters = psg_lstr_make_contiguous(filters, req->pool);
 		}
 
-		options.transaction = unionStationCore->newTransaction(
+		options.transaction = unionStationContext->newTransaction(
 			options.getAppGroupName(), "requests",
 			string(key->start->data, key->size),
 			(filters != NULL)
@@ -432,7 +424,7 @@ initializeUnionStation(Client *client, Request *req, RequestAnalysis &analysis)
 }
 
 void
-setStickySessionId(Client *client, Request *req) {
+Controller::setStickySessionId(Client *client, Request *req) {
 	if (req->stickySession) {
 		// TODO: This is not entirely correct. Clients MAY send multiple Cookie
 		// headers, although this is in practice extremely rare.
@@ -456,7 +448,7 @@ setStickySessionId(Client *client, Request *req) {
 }
 
 const LString *
-getStickySessionCookieName(Request *req) {
+Controller::getStickySessionCookieName(Request *req) {
 	const LString *value = req->headers.lookup(PASSENGER_STICKY_SESSIONS_COOKIE_NAME);
 	if (value == NULL || value->size == 0) {
 		return psg_lstr_create(req->pool,
@@ -465,3 +457,65 @@ getStickySessionCookieName(Request *req) {
 		return value;
 	}
 }
+
+
+/****************************
+ *
+ * Protected methods
+ *
+ ****************************/
+
+
+void
+Controller::onRequestBegin(Client *client, Request *req) {
+	ParentClass::onRequestBegin(client, req);
+
+	CC_BENCHMARK_POINT(client, req, BM_AFTER_ACCEPT);
+
+	{
+		// Perform hash table operations as close to header parsing as possible,
+		// and localize them as much as possible, for better CPU caching.
+		RequestAnalysis analysis;
+		analysis.flags = req->secureHeaders.lookup(FLAGS);
+		analysis.appGroupNameCell = singleAppMode
+			? NULL
+			: req->secureHeaders.lookupCell(PASSENGER_APP_GROUP_NAME);
+		analysis.unionStationSupport = unionStationContext != NULL
+			&& getBoolOption(req, UNION_STATION_SUPPORT, false);
+		req->stickySession = getBoolOption(req, PASSENGER_STICKY_SESSIONS,
+			this->stickySessions);
+		req->host = req->headers.lookup(HTTP_HOST);
+
+		/***************/
+		/***************/
+
+		SKC_TRACE(client, 2, "Initiating request");
+		req->startedAt = ev_now(getLoop());
+		req->bodyChannel.stop();
+
+		initializeFlags(client, req, analysis);
+		if (respondFromTurboCache(client, req)) {
+			return;
+		}
+		initializePoolOptions(client, req, analysis);
+		if (req->ended()) {
+			return;
+		}
+		initializeUnionStation(client, req, analysis);
+		if (req->ended()) {
+			return;
+		}
+		setStickySessionId(client, req);
+	}
+
+	if (!req->hasBody() || !req->requestBodyBuffering) {
+		req->requestBodyBuffering = false;
+		checkoutSession(client, req);
+	} else {
+		beginBufferingBody(client, req);
+	}
+}
+
+
+} // namespace Core
+} // namespace Passenger