passenger 5.0.21 → 5.0.22

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

@@ -0,0 +1,165 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2014-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>
+
+/*************************************************************************
+ *
+ * Initialization and shutdown-related code for Core::Controller
+ *
+ *************************************************************************/
+
+namespace Passenger {
+namespace Core {
+
+using namespace std;
+using namespace boost;
+
+
+/****************************
+ *
+ * Public methods
+ *
+ ****************************/
+
+
+Controller::Controller(ServerKit::Context *context, const VariantMap *_agentsOptions,
+	unsigned int _threadNumber)
+	: ParentClass(context),
+
+	  statThrottleRate(_agentsOptions->getInt("stat_throttle_rate")),
+	  responseBufferHighWatermark(_agentsOptions->getInt("response_buffer_high_watermark")),
+	  benchmarkMode(parseBenchmarkMode(_agentsOptions->get("benchmark_mode", false))),
+	  singleAppMode(false),
+	  showVersionInHeader(_agentsOptions->getBool("show_version_in_header")),
+	  stickySessions(_agentsOptions->getBool("sticky_sessions")),
+	  gracefulExit(_agentsOptions->getBool("core_graceful_exit")),
+
+	  agentsOptions(_agentsOptions),
+	  stringPool(psg_create_pool(1024 * 4)),
+	  poolOptionsCache(4),
+
+	  PASSENGER_APP_GROUP_NAME("!~PASSENGER_APP_GROUP_NAME"),
+	  PASSENGER_ENV_VARS("!~PASSENGER_ENV_VARS"),
+	  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))
+{
+	defaultRuby = psg_pstrdup(stringPool,
+		agentsOptions->get("default_ruby"));
+	ustRouterAddress = psg_pstrdup(stringPool,
+		agentsOptions->get("ust_router_address", false));
+	ustRouterPassword = psg_pstrdup(stringPool,
+		agentsOptions->get("ust_router_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"));
+	defaultStickySessionsCookieName = psg_pstrdup(stringPool,
+		agentsOptions->get("sticky_sessions_cookie_name"));
+
+	if (agentsOptions->has("vary_turbocache_by_cookie")) {
+		defaultVaryTurbocacheByCookie = psg_pstrdup(stringPool,
+			agentsOptions->get("vary_turbocache_by_cookie"));
+	}
+
+	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_CC_EVENT_LOOP_BLOCKING
+		ev_prepare_init(&prepareWatcher, onEventLoopPrepare);
+		ev_prepare_start(getLoop(), &prepareWatcher);
+		prepareWatcher.data = this;
+
+		timeBeforeBlocking = 0;
+	#endif
+}
+
+Controller::~Controller() {
+	psg_destroy_pool(stringPool);
+}
+
+void
+Controller::initialize() {
+	TRACE_POINT();
+	if (resourceLocator == NULL) {
+		throw RuntimeException("ResourceLocator not initialized");
+	}
+	if (appPool == NULL) {
+		throw RuntimeException("AppPool not initialized");
+	}
+	if (unionStationContext == NULL) {
+		unionStationContext = appPool->getUnionStationContext();
+	}
+}
+
+
+} // namespace Core
+} // namespace Passenger

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

@@ -23,21 +23,30 @@
  *  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.
+/*************************************************************************
+ *
+ * Internal utility functions for Core::Controller
+ *
+ *************************************************************************/
+
+namespace Passenger {
+namespace Core {
 
-#define RH_BENCHMARK_POINT(client, req, value) \
-	do { \
-		if (OXT_UNLIKELY(benchmarkMode == value)) { \
-			writeBenchmarkResponse(&client, &req); \
-			return; \
-		} \
-	} while (false)
+using namespace std;
+using namespace boost;
+
+
+/****************************
+ *
+ * Private methods
+ *
+ ****************************/
 
-private:
 
-static TurboCaching<Request>::State
-getTurboCachingInitialState(const VariantMap *agentsOptions) {
+TurboCaching<Request>::State
+Controller::getTurboCachingInitialState(const VariantMap *agentsOptions) {
 	bool enabled = agentsOptions->getBool("turbocaching", false, true);
 	if (enabled) {
 		return TurboCaching<Request>::ENABLED;
@@ -47,13 +56,13 @@ getTurboCachingInitialState(const VariantMap *agentsOptions) {
 }
 
 void
-generateServerLogName(unsigned int number) {
+Controller::generateServerLogName(unsigned int number) {
 	string name = "ServerThr." + toString(number);
 	serverLogName = psg_pstrdup(stringPool, name);
 }
 
 void
-disconnectWithClientSocketWriteError(Client **client, int e) {
+Controller::disconnectWithClientSocketWriteError(Client **client, int e) {
 	stringstream message;
 	PassengerLogLevel logLevel;
 	message << "client socket write error: ";
@@ -68,12 +77,12 @@ disconnectWithClientSocketWriteError(Client **client, int e) {
 }
 
 void
-disconnectWithAppSocketIncompleteResponseError(Client **client) {
+Controller::disconnectWithAppSocketIncompleteResponseError(Client **client) {
 	disconnectWithError(client, "application did not send a complete response");
 }
 
 void
-disconnectWithAppSocketReadError(Client **client, int e) {
+Controller::disconnectWithAppSocketReadError(Client **client, int e) {
 	stringstream message;
 	message << "app socket read error: ";
 	message << ServerKit::getErrorDesc(e);
@@ -82,7 +91,7 @@ disconnectWithAppSocketReadError(Client **client, int e) {
 }
 
 void
-disconnectWithAppSocketWriteError(Client **client, int e) {
+Controller::disconnectWithAppSocketWriteError(Client **client, int e) {
 	stringstream message;
 	message << "app socket write error: ";
 	message << ServerKit::getErrorDesc(e);
@@ -91,7 +100,7 @@ disconnectWithAppSocketWriteError(Client **client, int e) {
 }
 
 void
-endRequestWithAppSocketIncompleteResponse(Client **client, Request **req) {
+Controller::endRequestWithAppSocketIncompleteResponse(Client **client, Request **req) {
 	if (!(*req)->responseBegun) {
 		SKC_WARN(*client, "Sending 502 response: application did not send a complete response");
 		endRequestWithSimpleResponse(client, req,
@@ -102,7 +111,7 @@ endRequestWithAppSocketIncompleteResponse(Client **client, Request **req) {
 }
 
 void
-endRequestWithAppSocketReadError(Client **client, Request **req, int e) {
+Controller::endRequestWithAppSocketReadError(Client **client, Request **req, int e) {
 	Client *c = *client;
 	if (!(*req)->responseBegun) {
 		SKC_WARN(*client, "Sending 502 response: application socket read error");
@@ -116,7 +125,9 @@ endRequestWithAppSocketReadError(Client **client, Request **req, int e) {
  * `data` must outlive the request.
  */
 void
-endRequestWithSimpleResponse(Client **c, Request **r, const StaticString &body, int code = 200) {
+Controller::endRequestWithSimpleResponse(Client **c, Request **r,
+	const StaticString &body, int code)
+{
 	Client *client = *c;
 	Request *req = *r;
 	ServerKit::HeaderTable headers;
@@ -127,7 +138,7 @@ endRequestWithSimpleResponse(Client **c, Request **r, const StaticString &body,
 }
 
 void
-endRequestAsBadGateway(Client **client, Request **req) {
+Controller::endRequestAsBadGateway(Client **client, Request **req) {
 	if ((*req)->responseBegun) {
 		disconnectWithError(client, "bad gateway");
 	} else {
@@ -139,7 +150,7 @@ endRequestAsBadGateway(Client **client, Request **req) {
 }
 
 void
-writeBenchmarkResponse(Client **client, Request **req, bool end = true) {
+Controller::writeBenchmarkResponse(Client **client, Request **req, bool end) {
 	if (canKeepAlive(*req)) {
 		writeResponse(*client, P_STATIC_STRING(
 			"HTTP/1.1 200 OK\r\n"
@@ -167,7 +178,9 @@ writeBenchmarkResponse(Client **client, Request **req, bool end = true) {
 }
 
 bool
-getBoolOption(Request *req, const HashedStaticString &name, bool defaultValue = false) {
+Controller::getBoolOption(Request *req, const HashedStaticString &name,
+	bool defaultValue)
+{
 	const LString *value = req->secureHeaders.lookup(name);
 	if (value != NULL && value->size > 0) {
 		return psg_lstr_first_byte(value) == 't';
@@ -177,14 +190,14 @@ getBoolOption(Request *req, const HashedStaticString &name, bool defaultValue =
 }
 
 template<typename Number>
-static Number
-clamp(Number value, Number min, Number max) {
+Number
+Controller::clamp(Number value, Number min, Number max) {
 	return std::max(std::min(value, max), min);
 }
 
-static void
-gatherBuffers(char * restrict dest, unsigned int size, const struct iovec *buffers,
-	unsigned int nbuffers)
+void
+Controller::gatherBuffers(char * restrict dest, unsigned int size,
+	const struct iovec *buffers, unsigned int nbuffers)
 {
 	const char *end = dest + size;
 	char *pos = dest;
@@ -197,8 +210,8 @@ gatherBuffers(char * restrict dest, unsigned int size, const struct iovec *buffe
 }
 
 // `path` MUST be NULL-terminated. Returns a contiguous LString.
-static LString *
-resolveSymlink(const StaticString &path, psg_pool_t *pool) {
+LString *
+Controller::resolveSymlink(const StaticString &path, psg_pool_t *pool) {
 	char linkbuf[PATH_MAX + 1];
 	ssize_t size;
 
@@ -250,7 +263,7 @@ resolveSymlink(const StaticString &path, psg_pool_t *pool) {
 }
 
 void
-parseCookieHeader(psg_pool_t *pool, const LString *headerValue,
+Controller::parseCookieHeader(psg_pool_t *pool, const LString *headerValue,
 	vector< pair<StaticString, StaticString> > &cookies) const
 {
 	// See http://stackoverflow.com/questions/6108207/definite-guide-to-valid-cookie-values
@@ -291,9 +304,9 @@ parseCookieHeader(psg_pool_t *pool, const LString *headerValue,
 	}
 }
 
-#ifdef DEBUG_RH_EVENT_LOOP_BLOCKING
+#ifdef DEBUG_CC_EVENT_LOOP_BLOCKING
 	void
-	reportLargeTimeDiff(Client *client, const char *name,
+	Controller::reportLargeTimeDiff(Client *client, const char *name,
 		ev_tstamp fromTime, ev_tstamp toTime)
 	{
 		if (fromTime != 0 && toTime != 0) {
@@ -311,3 +324,7 @@ parseCookieHeader(psg_pool_t *pool, const LString *headerValue,
 		}
 	}
 #endif
+
+
+} // namespace Core
+} // namespace Passenger

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

@@ -0,0 +1,116 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2014-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>
+
+/*************************************************************************
+ *
+ * Miscellaneous functions for Core::Controller
+ *
+ *************************************************************************/
+
+namespace Passenger {
+namespace Core {
+
+using namespace std;
+using namespace boost;
+
+
+/****************************
+ *
+ * Public methods
+ *
+ ****************************/
+
+
+void
+Controller::disconnectLongRunningConnections(const StaticString &gupid) {
+	vector<Client *> clients;
+	vector<Client *>::iterator v_it, v_end;
+	Client *client;
+
+	// 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->options.abortWebsocketsOnProcessShutdown
+			 && req->session != NULL
+			 && req->session->getGupid() == gupid)
+			{
+				if (getLogLevel() >= LVL_INFO) {
+					char clientName[32];
+					unsigned int size;
+					const LString *host;
+					StaticString hostStr;
+
+					size = getClientName(client, clientName, sizeof(clientName));
+					if (req->host != NULL && req->host->size > 0) {
+						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);
+			}
+		}
+	}
+
+	// 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__);
+	}
+}
+
+Controller::BenchmarkMode
+Controller::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 {
+		return BM_UNKNOWN;
+	}
+}
+
+
+} // namespace Core
+} // namespace Passenger