passenger 4.0.60 → 5.0.0.beta1

data/ext/common/agents/HelperAgent/RequestHandler/Hooks.cpp

@@ -0,0 +1,231 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2011-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.
+ */
+
+// This file is included inside the RequestHandler class.
+
+public:
+
+virtual unsigned int getClientName(const Client *client, char *buf, size_t size) const {
+	char *pos = buf;
+	const char *end = buf + size - 1;
+	pos += uintToString(threadNumber, pos, end - pos);
+	pos = appendData(pos, end, ".", 1);
+	pos += uintToString(client->number, pos, end - pos);
+	*pos = '\0';
+	return pos - buf;
+}
+
+virtual StaticString getServerName() const {
+	return serverLogName;
+}
+
+protected:
+
+virtual void
+onClientAccepted(Client *client) {
+	ParentClass::onClientAccepted(client);
+	client->connectedAt = ev_now(getLoop());
+}
+
+virtual void
+onRequestObjectCreated(Client *client, Request *req) {
+	ParentClass::onRequestObjectCreated(client, req);
+
+	req->appSink.setContext(getContext());
+	req->appSink.setHooks(&req->hooks);
+
+	req->appSource.setContext(getContext());
+	req->appSource.setHooks(&req->hooks);
+	req->appSource.setDataCallback(_onAppSourceData);
+
+	req->bodyBuffer.setContext(getContext());
+	req->bodyBuffer.setHooks(&req->hooks);
+	req->bodyBuffer.setDataCallback(onBodyBufferData);
+}
+
+virtual void deinitializeClient(Client *client) {
+	ParentClass::deinitializeClient(client);
+	client->output.setBuffersFlushedCallback(NULL);
+}
+
+virtual void reinitializeRequest(Client *client, Request *req) {
+	ParentClass::reinitializeRequest(client, req);
+
+	// bodyBuffer is initialized in RequestHandler::beginBufferingBody().
+	// appSink and appSource are initialized in RequestHandler::checkoutSession().
+
+	req->startedAt = 0;
+	req->state = Request::ANALYZING_REQUEST;
+	req->dechunkResponse = false;
+	req->requestBodyBuffering = false;
+	req->https = false;
+	req->stickySession = false;
+	req->halfCloseAppConnection = false;
+	req->sessionCheckoutTry = 0;
+	req->strip100ContinueHeader = false;
+	req->hasPragmaHeader = false;
+	req->host = NULL;
+	req->bodyBytesBuffered = 0;
+	req->cacheKey = HashedStaticString();
+	req->cacheControl = NULL;
+
+	#ifdef DEBUG_RH_EVENT_LOOP_BLOCKING
+		req->timedAppPoolGet = false;
+		req->timeBeforeAccessingApplicationPool = 0;
+		req->timeOnRequestHeaderSent = 0;
+		req->timeOnResponseBegun = 0;
+	#endif
+
+	/***************/
+}
+
+virtual void deinitializeRequest(Client *client, Request *req) {
+	req->session.reset();
+
+	req->endScopeLog(&req->scopeLogs.requestProxying, false);
+	req->endScopeLog(&req->scopeLogs.getFromPool, false);
+	req->endScopeLog(&req->scopeLogs.bufferingRequestBody, false);
+	req->endScopeLog(&req->scopeLogs.requestProcessing, false);
+
+	req->appSink.setConsumedCallback(NULL);
+	req->appSink.deinitialize();
+	req->appSource.deinitialize();
+	req->bodyBuffer.deinitialize();
+
+	/***************/
+	/***************/
+
+	deinitializeAppResponse(client, req);
+
+	ParentClass::deinitializeRequest(client, req);
+}
+
+void reinitializeAppResponse(Client *client, Request *req) {
+	AppResponse *resp = &req->appResponse;
+
+	resp->httpMajor = 1;
+	resp->httpMinor = 0;
+	resp->httpState = AppResponse::PARSING_HEADERS;
+	resp->bodyType  = AppResponse::RBT_NO_BODY;
+	resp->wantKeepAlive = false;
+	resp->oneHundredContinueSent = false;
+	resp->statusCode = 0;
+	resp->parserState.headerParser = getHeaderParserStatePool().construct();
+	createAppResponseHeaderParser(getContext(), req).initialize();
+	resp->aux.bodyInfo.contentLength = 0; // Sets the entire union to 0.
+	resp->bodyAlreadyRead = 0;
+	resp->date = NULL;
+	resp->cacheControl = NULL;
+	resp->expiresHeader = NULL;
+	resp->lastModifiedHeader = NULL;
+
+	resp->headerCacheBuffers = NULL;
+	resp->nHeaderCacheBuffers = 0;
+	psg_lstr_init(&resp->bodyCacheBuffer);
+}
+
+void deinitializeAppResponse(Client *client, Request *req) {
+	AppResponse *resp = &req->appResponse;
+
+	if (resp->httpState == AppResponse::PARSING_HEADERS
+	 && resp->parserState.headerParser != NULL)
+	{
+		getHeaderParserStatePool().destroy(resp->parserState.headerParser);
+		resp->parserState.headerParser = NULL;
+	}
+
+	ServerKit::HeaderTable::Iterator it(resp->headers);
+	while (*it != NULL) {
+		psg_lstr_deinit(&it->header->key);
+		psg_lstr_deinit(&it->header->val);
+		it.next();
+	}
+
+	it = ServerKit::HeaderTable::Iterator(resp->secureHeaders);
+	while (*it != NULL) {
+		psg_lstr_deinit(&it->header->key);
+		psg_lstr_deinit(&it->header->val);
+		it.next();
+	}
+
+	resp->headers.clear();
+	resp->secureHeaders.clear();
+
+	psg_lstr_deinit(&resp->bodyCacheBuffer);
+}
+
+virtual Channel::Result
+onRequestBody(Client *client, Request *req, const MemoryKit::mbuf &buffer,
+	int errcode)
+{
+	switch (req->state) {
+	case Request::BUFFERING_REQUEST_BODY:
+		return whenBufferingBody_onRequestBody(client, req, buffer, errcode);
+	case Request::FORWARDING_BODY_TO_APP:
+		return whenSendingRequest_onRequestBody(client, req, buffer, errcode);
+	default:
+		P_BUG("Unknown state " << req->state);
+		return Channel::Result(0, false);
+	}
+}
+
+virtual bool
+shouldDisconnectClientOnShutdown(Client *client) {
+	return ParentClass::shouldDisconnectClientOnShutdown(client) || !gracefulExit;
+}
+
+private:
+
+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);
+}
+
+#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
+}

data/ext/common/agents/HelperAgent/RequestHandler/InitRequest.cpp

@@ -0,0 +1,434 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2011-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.
+ */
+
+// This file is included inside the RequestHandler class.
+
+protected:
+
+struct RequestAnalysis {
+	const LString *flags;
+	ServerKit::HeaderTable::Cell *appGroupNameCell;
+	bool unionStationSupport;
+};
+
+virtual void
+onRequestBegin(Client *client, Request *req) {
+	ParentClass::onRequestBegin(client, req);
+
+	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, false);
+		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);
+	}
+}
+
+virtual bool
+supportsUpgrade(Client *client, Request *req) {
+	return true;
+}
+
+private:
+
+void
+initializeFlags(Client *client, Request *req, RequestAnalysis &analysis) {
+	if (analysis.flags != NULL) {
+		const LString::Part *part = analysis.flags->start;
+		while (part != NULL) {
+			const char *data = part->data;
+			const char *end  = part->data + part->size;
+			while (data < end) {
+				switch (*data) {
+				case 'D':
+					req->dechunkResponse = true;
+					break;
+				case 'B':
+					req->requestBodyBuffering = true;
+					break;
+				case 'S':
+					req->https = true;
+					break;
+				case 'C':
+					req->strip100ContinueHeader = true;
+					break;
+				default:
+					break;
+				}
+				data++;
+			}
+			part = part->next;
+		}
+
+		if (OXT_UNLIKELY(getLogLevel() >= LVL_DEBUG2)) {
+			if (req->dechunkResponse) {
+				SKC_TRACE(client, 2, "Dechunk flag detected");
+			}
+			if (req->requestBodyBuffering) {
+				SKC_TRACE(client, 2, "Request body buffering enabled");
+			}
+			if (req->https) {
+				SKC_TRACE(client, 2, "HTTPS flag detected");
+			}
+			if (req->strip100ContinueHeader) {
+				SKC_TRACE(client, 2, "Stripping 100 Continue header");
+			}
+		}
+	}
+}
+
+bool
+respondFromTurboCache(Client *client, Request *req) {
+	if (!turboCaching.isEnabled() || !turboCaching.responseCache.prepareRequest(req)) {
+		return false;
+	}
+
+	SKC_TRACE(client, 2, "Turbocaching: trying to reply from cache");
+	SKC_TRACE(client, 2, "Turbocache entries:\n" << turboCaching.responseCache.inspect());
+
+	if (turboCaching.responseCache.requestAllowsFetching(req)) {
+		ResponseCache<Request>::Entry entry(turboCaching.responseCache.fetch(req,
+			ev_now(getLoop())));
+		if (entry.valid()) {
+			SKC_TRACE(client, 2, "Turbocaching: cache hit (key " << req->cacheKey << ")");
+			turboCaching.writeResponse(this, client, req, entry);
+			if (!req->ended()) {
+				endRequest(&client, &req);
+			}
+			return true;
+		} else {
+			SKC_TRACE(client, 2, "Turbocaching: cache miss (key " << req->cacheKey << ")");
+			return false;
+		}
+	} else {
+		SKC_TRACE(client, 2, "Turbocaching: request not eligible for caching");
+		return false;
+	}
+}
+
+void
+initializePoolOptions(Client *client, Request *req, RequestAnalysis &analysis) {
+	boost::shared_ptr<Options> *options;
+
+	if (singleAppMode) {
+		P_ASSERT_EQ(poolOptionsCache.size(), 1);
+		poolOptionsCache.lookupRandom(NULL, &options);
+		req->options = **options;
+	} else {
+		ServerKit::HeaderTable::Cell *appGroupNameCell = analysis.appGroupNameCell;
+		if (appGroupNameCell != NULL && appGroupNameCell->header->val.size > 0) {
+			const LString *appGroupName = psg_lstr_make_contiguous(
+				&appGroupNameCell->header->val,
+				req->pool);
+			HashedStaticString hAppGroupName(appGroupName->start->data,
+				appGroupName->size);
+
+			poolOptionsCache.lookup(hAppGroupName, &options);
+
+			if (options != NULL) {
+				req->options = **options;
+			} else {
+				createNewPoolOptions(client, req, hAppGroupName);
+			}
+		} else {
+			disconnectWithError(&client, "the !~PASSENGER_APP_GROUP_NAME header must be set");
+			return;
+		}
+	}
+
+	if (!req->ended()) {
+		fillPoolOption(req, req->options.maxRequests, PASSENGER_MAX_REQUESTS);
+	}
+}
+
+void
+fillPoolOptionsFromAgentsOptions(Options &options) {
+	options.ruby = defaultRuby;
+	options.logLevel = getLogLevel();
+	options.loggingAgentAddress = loggingAgentAddress;
+	options.loggingAgentUsername = P_STATIC_STRING("logging");
+	options.loggingAgentPassword = loggingAgentPassword;
+	if (!this->defaultUser.empty()) {
+		options.defaultUser = defaultUser;
+	}
+	if (!this->defaultGroup.empty()) {
+		options.defaultGroup = defaultGroup;
+	}
+	options.minProcesses = agentsOptions->getInt("min_instances");
+	options.spawnMethod = agentsOptions->get("spawn_method");
+	options.loadShellEnvvars = agentsOptions->getBool("load_shell_envvars");
+	options.statThrottleRate = statThrottleRate;
+
+	/******************************/
+}
+
+static void
+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);
+		field = StaticString(value->start->data, value->size);
+	}
+}
+
+static void
+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) {
+	const LString *value = req->secureHeaders.lookup(name);
+	if (value != NULL && value->size > 0) {
+		value = psg_lstr_make_contiguous(value, req->pool);
+		field = stringToUint(StaticString(value->start->data, value->size));
+	}
+}
+
+static void
+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);
+		field = stringToUint(StaticString(value->start->data, value->size));
+	}
+}
+
+static void
+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);
+		field = stringToInt(StaticString(value->start->data, value->size));
+	}
+}
+
+static void
+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);
+		field = stringToInt(StaticString(value->start->data, value->size)) * 1000;
+	}
+}
+
+void
+createNewPoolOptions(Client *client, Request *req, const HashedStaticString &appGroupName) {
+	ServerKit::HeaderTable &secureHeaders = req->secureHeaders;
+	Options &options = req->options;
+
+	SKC_TRACE(client, 2, "Creating new pool options: app group name=" << appGroupName);
+
+	options = Options();
+
+	const LString *scriptName = secureHeaders.lookup("!~SCRIPT_NAME");
+	const LString *appRoot = secureHeaders.lookup("!~PASSENGER_APP_ROOT");
+	if (scriptName == NULL || scriptName->size == 0) {
+		if (appRoot == NULL || appRoot->size == 0) {
+			const LString *documentRoot = secureHeaders.lookup("!~DOCUMENT_ROOT");
+			if (OXT_UNLIKELY(documentRoot == NULL || documentRoot->size == 0)) {
+				disconnectWithError(&client, "client did not send a !~PASSENGER_APP_ROOT or a !~DOCUMENT_ROOT header");
+				return;
+			}
+
+			documentRoot = psg_lstr_make_contiguous(documentRoot, req->pool);
+			appRoot = psg_lstr_create(req->pool,
+				extractDirNameStatic(StaticString(documentRoot->start->data,
+					documentRoot->size)));
+		} else {
+			appRoot = psg_lstr_make_contiguous(appRoot, req->pool);
+		}
+		options.appRoot = HashedStaticString(appRoot->start->data, appRoot->size);
+	} else {
+		if (appRoot == NULL || appRoot->size == 0) {
+			const LString *documentRoot = secureHeaders.lookup("!~DOCUMENT_ROOT");
+			if (OXT_UNLIKELY(documentRoot == NULL || documentRoot->size == 0)) {
+				disconnectWithError(&client, "client did not send a !~DOCUMENT_ROOT header");
+				return;
+			}
+
+			documentRoot = psg_lstr_null_terminate(documentRoot, req->pool);
+			documentRoot = resolveSymlink(StaticString(documentRoot->start->data,
+				documentRoot->size), req->pool);
+			appRoot = psg_lstr_create(req->pool,
+				extractDirNameStatic(StaticString(documentRoot->start->data,
+					documentRoot->size)));
+		} else {
+			appRoot = psg_lstr_make_contiguous(appRoot, req->pool);
+		}
+		options.appRoot = HashedStaticString(appRoot->start->data, appRoot->size);
+		scriptName = psg_lstr_make_contiguous(scriptName, req->pool);
+		options.baseURI = StaticString(scriptName->start->data, scriptName->size);
+	}
+
+	fillPoolOptionsFromAgentsOptions(options);
+
+	const LString *appType = secureHeaders.lookup("!~PASSENGER_APP_TYPE");
+	if (appType == NULL || appType->size == 0) {
+		AppTypeDetector detector;
+		PassengerAppType type = detector.checkAppRoot(options.appRoot);
+		// TODO: check for errors
+		options.appType = getAppTypeName(type);
+	} else {
+		fillPoolOption(req, options.appType, "!~PASSENGER_APP_TYPE");
+	}
+
+	options.appGroupName = appGroupName;
+
+	fillPoolOption(req, options.appType, "!~PASSENGER_APP_TYPE");
+	fillPoolOption(req, options.environment, "!~PASSENGER_APP_ENV");
+	fillPoolOption(req, options.ruby, "!~PASSENGER_RUBY");
+	fillPoolOption(req, options.python, "!~PASSENGER_PYTHON");
+	fillPoolOption(req, options.nodejs, "!~PASSENGER_NODEJS");
+	fillPoolOption(req, options.user, "!~PASSENGER_USER");
+	fillPoolOption(req, options.group, "!~PASSENGER_GROUP");
+	fillPoolOption(req, options.minProcesses, "!~PASSENGER_MIN_PROCESSES");
+	fillPoolOption(req, options.maxProcesses, "!~PASSENGER_MAX_PROCESSES");
+	fillPoolOption(req, options.spawnMethod, "!~PASSENGER_SPAWN_METHOD");
+	fillPoolOption(req, options.startCommand, "!~PASSENGER_START_COMMAND");
+	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.restartDir, "!~PASSENGER_RESTART_DIR");
+	fillPoolOption(req, options.startupFile, "!~PASSENGER_STARTUP_FILE");
+	fillPoolOption(req, options.loadShellEnvvars, "!~PASSENGER_LOAD_SHELL_ENVVARS");
+	fillPoolOption(req, options.debugger, "!~PASSENGER_DEBUGGER");
+	fillPoolOption(req, options.environmentVariables, "!~PASSENGER_ENV_VARS");
+	fillPoolOption(req, options.raiseInternalError, "!~PASSENGER_RAISE_INTERNAL_ERROR");
+	/******************/
+
+	boost::shared_ptr<Options> optionsCopy = boost::make_shared<Options>(options);
+	optionsCopy->persist(options);
+	optionsCopy->clearPerRequestFields();
+	optionsCopy->detachFromUnionStationTransaction();
+	poolOptionsCache.insert(options.getAppGroupName(), optionsCopy);
+}
+
+void
+initializeUnionStation(Client *client, Request *req, RequestAnalysis &analysis) {
+	if (analysis.unionStationSupport) {
+		Options &options = req->options;
+		ServerKit::HeaderTable &headers = req->secureHeaders;
+
+		const LString *key = headers.lookup("!~UNION_STATION_KEY");
+		if (key == NULL || key->size == 0) {
+			disconnectWithError(&client, "header !~UNION_STATION_KEY must be set.");
+			return;
+		}
+		key = psg_lstr_make_contiguous(key, req->pool);
+
+		const LString *filters = headers.lookup("!~UNION_STATION_FILTERS");
+		if (filters != NULL) {
+			filters = psg_lstr_make_contiguous(filters, req->pool);
+		}
+
+		options.transaction = unionStationCore->newTransaction(
+			options.getAppGroupName(), "requests",
+			string(key->start->data, key->size),
+			(filters != NULL)
+				? string(filters->start->data, filters->size)
+				: string());
+		if (!options.transaction->isNull()) {
+			options.analytics = true;
+			options.unionStationKey = StaticString(key->start->data, key->size);
+		}
+
+		req->beginScopeLog(&req->scopeLogs.requestProcessing, "request processing");
+		req->logMessage(string("Request method: ") + http_method_str(req->method));
+		req->logMessage("URI: " + StaticString(req->path.start->data, req->path.size));
+	}
+}
+
+void
+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.
+		// http://stackoverflow.com/questions/16305814/are-multiple-cookie-headers-allowed-in-an-http-request
+		const LString *cookieHeader = req->headers.lookup(HTTP_COOKIE);
+		const LString *cookieName = getStickySessionCookieName(req);
+		vector< pair<StaticString, StaticString> > cookies;
+		pair<StaticString, StaticString> cookie;
+
+		parseCookieHeader(req->pool, cookieHeader, cookies);
+		foreach (cookie, cookies) {
+			if (psg_lstr_cmp(cookieName, cookie.first)) {
+				// This cookie matches the one we're looking for.
+				req->options.stickySessionId = stringToUint(cookie.second);
+				return;
+			}
+		}
+	}
+}
+
+const LString *
+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,
+			P_STATIC_STRING(DEFAULT_STICKY_SESSIONS_COOKIE_NAME));
+	} else {
+		return value;
+	}
+}