passenger 5.0.21 → 5.0.22

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

@@ -0,0 +1,161 @@
+/*
+ *  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>
+
+/*************************************************************************
+ *
+ * State inspection functions for Core::Controller
+ *
+ *************************************************************************/
+
+namespace Passenger {
+namespace Core {
+
+using namespace std;
+using namespace boost;
+
+
+/****************************
+ *
+ * Public methods
+ *
+ ****************************/
+
+
+Json::Value
+Controller::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;
+}
+
+void
+Controller::configure(const Json::Value &doc) {
+	ParentClass::configure(doc);
+	if (doc.isMember("show_version_in_header")) {
+		showVersionInHeader = doc["show_version_in_header"].asBool();
+	}
+	if (doc.isMember("data_buffer_dir")) {
+		getContext()->defaultFileBufferedChannelConfig.bufferDir =
+			doc["data_buffer_dir"].asString();
+	}
+}
+
+Json::Value
+Controller::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;
+}
+
+Json::Value
+Controller::inspectClientStateAsJson(const Client *client) const {
+	Json::Value doc = ParentClass::inspectClientStateAsJson(client);
+	doc["connected_at"] = timeToJson(client->connectedAt * 1000000.0);
+	return doc;
+}
+
+Json::Value
+Controller::inspectRequestStateAsJson(const Request *req) const {
+	Json::Value doc = ParentClass::inspectRequestStateAsJson(req);
+	Json::Value flags;
+	const AppResponse *resp = &req->appResponse;
+
+	if (req->startedAt != 0) {
+		doc["started_at"] = timeToJson(req->startedAt * 1000000.0);
+	}
+	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;
+
+	flags["dechunk_response"] = req->dechunkResponse;
+	flags["request_body_buffering"] = req->requestBodyBuffering;
+	flags["https"] = req->https;
+	doc["flags"] = flags;
+
+	if (req->requestBodyBuffering) {
+		doc["body_bytes_buffered"] = byteSizeToJson(req->bodyBytesBuffered);
+	}
+
+	if (req->session != NULL) {
+		Json::Value &sessionDoc = doc["session"] = Json::Value(Json::objectValue);
+		const Session *session = req->session.get();
+
+		if (req->session->isClosed()) {
+			sessionDoc["closed"] = true;
+		} else {
+			sessionDoc["pid"] = (Json::Int64) session->getPid();
+			sessionDoc["gupid"] = session->getGupid().toString();
+		}
+	}
+
+	if (req->appResponseInitialized) {
+		doc["app_response_http_state"] = resp->getHttpStateString();
+		if (resp->begun()) {
+			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"] = byteSizeToJson(
+				resp->bodyAlreadyRead);
+			if (resp->httpState != AppResponse::ERROR) {
+				if (resp->bodyType == AppResponse::RBT_CONTENT_LENGTH) {
+					doc["app_response_content_length"] = byteSizeToJson(
+						resp->aux.bodyInfo.contentLength);
+				} else if (resp->bodyType == AppResponse::RBT_CHUNKED) {
+					doc["app_response_end_chunk_reached"] = resp->aux.bodyInfo.endChunkReached;
+				}
+			} else {
+				doc["app_response_parse_error"] = ServerKit::getErrorDesc(resp->aux.parseError);
+			}
+		}
+	}
+
+	doc["app_source_state"] = req->appSource.inspectAsJson();
+	doc["app_sink_state"] = req->appSink.inspectAsJson();
+
+	return doc;
+}
+
+
+} // namespace Core
+} // namespace Passenger

data/src/agent/Core/{RequestHandler → Controller}/TurboCaching.h

@@ -39,6 +39,8 @@
 #include <Core/ResponseCache.h>
 
 namespace Passenger {
+namespace Core {
+
 
 using namespace std;
 
@@ -290,6 +292,7 @@ public:
 };
 
 
+} // namespace Core
 } // namespace Passenger
 
 #endif /* _PASSENGER_TURBO_CACHING_H_ */

data/src/agent/Core/CoreMain.cpp

@@ -84,10 +84,10 @@
 #include <Utils/MessageIO.h>
 #include <Utils/VariantMap.h>
 #include <Core/OptionParser.h>
-#include <Core/RequestHandler.h>
+#include <Core/Controller.h>
 #include <Core/ApiServer.h>
 #include <Core/ApplicationPool/Pool.h>
-#include <Core/UnionStation/Core.h>
+#include <Core/UnionStation/Context.h>
 
 using namespace boost;
 using namespace oxt;
@@ -102,19 +102,19 @@ namespace Core {
 	struct ThreadWorkingObjects {
 		BackgroundEventLoop *bgloop;
 		ServerKit::Context *serverKitContext;
-		RequestHandler *requestHandler;
+		Controller *controller;
 
 		ThreadWorkingObjects()
 			: bgloop(NULL),
 			  serverKitContext(NULL),
-			  requestHandler(NULL)
+			  controller(NULL)
 			{ }
 	};
 
 	struct ApiWorkingObjects {
 		BackgroundEventLoop *bgloop;
 		ServerKit::Context *serverKitContext;
-		ApiServer *apiServer;
+		ApiServer::ApiServer *apiServer;
 
 		ApiWorkingObjects()
 			: bgloop(NULL),
@@ -131,12 +131,12 @@ namespace Core {
 
 		ResourceLocator resourceLocator;
 		RandomGeneratorPtr randomGenerator;
-		UnionStation::CorePtr unionStationCore;
+		UnionStation::ContextPtr unionStationContext;
 		SpawningKit::ConfigPtr spawningKitConfig;
 		SpawningKit::FactoryPtr spawningKitFactory;
 		PoolPtr appPool;
 
-		ServerKit::AcceptLoadBalancer<RequestHandler> loadBalancer;
+		ServerKit::AcceptLoadBalancer<Controller> loadBalancer;
 		vector<ThreadWorkingObjects> threadWorkingObjects;
 		struct ev_signal sigintWatcher;
 		struct ev_signal sigtermWatcher;
@@ -167,7 +167,7 @@ namespace Core {
 
 			vector<ThreadWorkingObjects>::iterator it, end = threadWorkingObjects.end();
 			for (it = threadWorkingObjects.begin(); it != end; it++) {
-				delete it->requestHandler;
+				delete it->controller;
 				delete it->serverKitContext;
 				delete it->bgloop;
 			}
@@ -192,8 +192,8 @@ static void waitForExitEvent();
 static void cleanup();
 static void deletePidFile();
 static void abortLongRunningConnections(const ApplicationPool2::ProcessPtr &process);
-static void requestHandlerShutdownFinished(RequestHandler *server);
-static void apiServerShutdownFinished(Core::ApiServer *server);
+static void controllerShutdownFinished(Controller *controller);
+static void apiServerShutdownFinished(Core::ApiServer::ApiServer *server);
 static void printInfoInThread();
 
 static void
@@ -377,13 +377,13 @@ printInfo(EV_P_ struct ev_signal *watcher, int revents) {
 }
 
 static void
-inspectRequestHandlerStateAsJson(RequestHandler *rh, string *result) {
-	*result = rh->inspectStateAsJson().toStyledString();
+inspectControllerStateAsJson(Controller *controller, string *result) {
+	*result = controller->inspectStateAsJson().toStyledString();
 }
 
 static void
-inspectRequestHandlerConfigAsJson(RequestHandler *rh, string *result) {
-	*result = rh->getConfigAsJson().toStyledString();
+inspectControllerConfigAsJson(Controller *controller, string *result) {
+	*result = controller->getConfigAsJson().toStyledString();
 }
 
 static void
@@ -407,8 +407,8 @@ printInfoInThread() {
 		string json;
 
 		cerr << "### Request handler state (thread " << (i + 1) << ")\n";
-		two->bgloop->safe->runSync(boost::bind(inspectRequestHandlerStateAsJson,
-			two->requestHandler, &json));
+		two->bgloop->safe->runSync(boost::bind(inspectControllerStateAsJson,
+			two->controller, &json));
 		cerr << json;
 		cerr << "\n";
 		cerr.flush();
@@ -419,8 +419,8 @@ printInfoInThread() {
 		string json;
 
 		cerr << "### Request handler config (thread " << (i + 1) << ")\n";
-		two->bgloop->safe->runSync(boost::bind(inspectRequestHandlerConfigAsJson,
-			two->requestHandler, &json));
+		two->bgloop->safe->runSync(boost::bind(inspectControllerConfigAsJson,
+			two->controller, &json));
 		cerr << json;
 		cerr << "\n";
 		cerr.flush();
@@ -455,7 +455,7 @@ dumpDiagnosticsOnCrash(void *userData) {
 	for (i = 0; i < wo->threadWorkingObjects.size(); i++) {
 		ThreadWorkingObjects *two = &wo->threadWorkingObjects[i];
 		cerr << "### Request handler state (thread " << (i + 1) << ")\n";
-		cerr << two->requestHandler->inspectStateAsJson();
+		cerr << two->controller->inspectStateAsJson();
 		cerr << "\n";
 		cerr.flush();
 	}
@@ -463,7 +463,7 @@ dumpDiagnosticsOnCrash(void *userData) {
 	for (i = 0; i < wo->threadWorkingObjects.size(); i++) {
 		ThreadWorkingObjects *two = &wo->threadWorkingObjects[i];
 		cerr << "### Request handler config (thread " << (i + 1) << ")\n";
-		cerr << two->requestHandler->getConfigAsJson();
+		cerr << two->controller->getConfigAsJson();
 		cerr << "\n";
 		cerr.flush();
 	}
@@ -547,7 +547,7 @@ initializeNonPrivilegedWorkingObjects() {
 
 	UPDATE_TRACE_POINT();
 	if (options.has("ust_router_address")) {
-		wo->unionStationCore = boost::make_shared<UnionStation::Core>(
+		wo->unionStationContext = boost::make_shared<UnionStation::Context>(
 			options.get("ust_router_address"),
 			"logging",
 			options.get("ust_router_password"));
@@ -558,7 +558,7 @@ initializeNonPrivilegedWorkingObjects() {
 	wo->spawningKitConfig->resourceLocator = &wo->resourceLocator;
 	wo->spawningKitConfig->agentsOptions = agentsOptions;
 	wo->spawningKitConfig->errorHandler = spawningKitErrorHandler;
-	wo->spawningKitConfig->unionStationCore = wo->unionStationCore;
+	wo->spawningKitConfig->unionStationContext = wo->unionStationContext;
 	wo->spawningKitConfig->randomGenerator = wo->randomGenerator;
 	wo->spawningKitConfig->instanceDir = options.get("instance_dir", false);
 	if (!wo->spawningKitConfig->instanceDir.empty()) {
@@ -600,14 +600,14 @@ initializeNonPrivilegedWorkingObjects() {
 			options.getUint("file_buffer_threshold");
 
 		UPDATE_TRACE_POINT();
-		two.requestHandler = new RequestHandler(two.serverKitContext, agentsOptions, i + 1);
-		two.requestHandler->minSpareClients = 128;
-		two.requestHandler->clientFreelistLimit = 1024;
-		two.requestHandler->resourceLocator = &wo->resourceLocator;
-		two.requestHandler->appPool = wo->appPool;
-		two.requestHandler->unionStationCore = wo->unionStationCore;
-		two.requestHandler->shutdownFinishCallback = requestHandlerShutdownFinished;
-		two.requestHandler->initialize();
+		two.controller = new Core::Controller(two.serverKitContext, agentsOptions, i + 1);
+		two.controller->minSpareClients = 128;
+		two.controller->clientFreelistLimit = 1024;
+		two.controller->resourceLocator = &wo->resourceLocator;
+		two.controller->appPool = wo->appPool;
+		two.controller->unionStationContext = wo->unionStationContext;
+		two.controller->shutdownFinishCallback = controllerShutdownFinished;
+		two.controller->initialize();
 		wo->shutdownCounter.fetch_add(1, boost::memory_order_relaxed);
 
 		wo->threadWorkingObjects.push_back(two);
@@ -636,11 +636,11 @@ initializeNonPrivilegedWorkingObjects() {
 			options.getUint("file_buffer_threshold");
 
 		UPDATE_TRACE_POINT();
-		awo->apiServer = new Core::ApiServer(awo->serverKitContext);
-		awo->apiServer->requestHandlers.reserve(wo->threadWorkingObjects.size());
+		awo->apiServer = new Core::ApiServer::ApiServer(awo->serverKitContext);
+		awo->apiServer->controllers.reserve(wo->threadWorkingObjects.size());
 		for (unsigned int i = 0; i < wo->threadWorkingObjects.size(); i++) {
-			awo->apiServer->requestHandlers.push_back(
-				wo->threadWorkingObjects[i].requestHandler);
+			awo->apiServer->controllers.push_back(
+				wo->threadWorkingObjects[i].controller);
 		}
 		awo->apiServer->apiAccountDatabase = &wo->apiAccountDatabase;
 		awo->apiServer->appPool = wo->appPool;
@@ -663,20 +663,20 @@ initializeNonPrivilegedWorkingObjects() {
 	for (unsigned int i = 0; i < addresses.size(); i++) {
 		if (nthreads == 1) {
 			ThreadWorkingObjects *two = &wo->threadWorkingObjects[0];
-			two->requestHandler->listen(wo->serverFds[i]);
+			two->controller->listen(wo->serverFds[i]);
 		} else {
 			wo->loadBalancer.listen(wo->serverFds[i]);
 		}
 	}
 	for (unsigned int i = 0; i < nthreads; i++) {
 		ThreadWorkingObjects *two = &wo->threadWorkingObjects[i];
-		two->requestHandler->createSpareClients();
+		two->controller->createSpareClients();
 	}
 	if (nthreads > 1) {
 		wo->loadBalancer.servers.reserve(nthreads);
 		for (unsigned int i = 0; i < nthreads; i++) {
 			ThreadWorkingObjects *two = &wo->threadWorkingObjects[i];
-			wo->loadBalancer.servers.push_back(two->requestHandler);
+			wo->loadBalancer.servers.push_back(two->controller);
 		}
 	}
 	for (unsigned int i = 0; i < apiAddresses.size(); i++) {
@@ -780,10 +780,10 @@ mainLoop() {
 }
 
 static void
-abortLongRunningConnectionsOnRequestHandler(RequestHandler *requestHandler,
+abortLongRunningConnectionsOnController(Core::Controller *controller,
 	string gupid)
 {
-	requestHandler->disconnectLongRunningConnections(gupid);
+	controller->disconnectLongRunningConnections(gupid);
 }
 
 static void
@@ -794,15 +794,15 @@ abortLongRunningConnections(const ApplicationPool2::ProcessPtr &process) {
 		process->getPid() << ", application " << process->getGroup()->getName());
 	for (unsigned int i = 0; i < wo->threadWorkingObjects.size(); i++) {
 		wo->threadWorkingObjects[i].bgloop->safe->runLater(
-			boost::bind(abortLongRunningConnectionsOnRequestHandler,
-				wo->threadWorkingObjects[i].requestHandler,
+			boost::bind(abortLongRunningConnectionsOnController,
+				wo->threadWorkingObjects[i].controller,
 				process->getGupid().toString()));
 	}
 }
 
 static void
-shutdownRequestHandler(ThreadWorkingObjects *two) {
-	two->requestHandler->shutdown();
+shutdownController(ThreadWorkingObjects *two) {
+	two->controller->shutdown();
 }
 
 static void
@@ -820,12 +820,12 @@ serverShutdownFinished() {
 }
 
 static void
-requestHandlerShutdownFinished(RequestHandler *server) {
+controllerShutdownFinished(Core::Controller *controller) {
 	serverShutdownFinished();
 }
 
 static void
-apiServerShutdownFinished(Core::ApiServer *server) {
+apiServerShutdownFinished(Core::ApiServer::ApiServer *server) {
 	serverShutdownFinished();
 }
 
@@ -878,7 +878,7 @@ waitForExitEvent() {
 
 		for (unsigned i = 0; i < wo->threadWorkingObjects.size(); i++) {
 			ThreadWorkingObjects *two = &wo->threadWorkingObjects[i];
-			two->bgloop->safe->runLater(boost::bind(shutdownRequestHandler, two));
+			two->bgloop->safe->runLater(boost::bind(shutdownController, two));
 		}
 		if (wo->threadWorkingObjects.size() > 1) {
 			wo->loadBalancer.shutdown();
@@ -920,8 +920,8 @@ cleanup() {
 	wo->appPool.reset();
 	for (unsigned i = 0; i < wo->threadWorkingObjects.size(); i++) {
 		ThreadWorkingObjects *two = &wo->threadWorkingObjects[i];
-		delete two->requestHandler;
-		two->requestHandler = NULL;
+		delete two->controller;
+		two->controller = NULL;
 	}
 	if (wo->prestarterThread != NULL) {
 		wo->prestarterThread->interrupt_and_join();
@@ -1052,13 +1052,16 @@ setAgentsOptionsDefaults() {
 	options.setDefault("environment", DEFAULT_APP_ENV);
 	options.setDefault("spawn_method", DEFAULT_SPAWN_METHOD);
 	options.setDefaultBool("load_shell_envvars", false);
+	options.setDefaultBool("abort_websockets_on_process_shutdown", true);
+	options.setDefaultInt("force_max_concurrent_requests_per_process", -1);
 	options.setDefault("concurrency_model", DEFAULT_CONCURRENCY_MODEL);
 	options.setDefaultInt("app_thread_count", DEFAULT_APP_THREAD_COUNT);
 	options.setDefaultInt("max_pool_size", DEFAULT_MAX_POOL_SIZE);
 	options.setDefaultInt("pool_idle_time", DEFAULT_POOL_IDLE_TIME);
 	options.setDefaultInt("min_instances", 1);
 	options.setDefaultInt("max_preloader_idle_time", DEFAULT_MAX_PRELOADER_IDLE_TIME);
-	options.setDefaultInt("stat_throttle_rate", DEFAULT_STAT_THROTTLE_RATE);
+	options.setDefaultUint("max_request_queue_size", DEFAULT_MAX_REQUEST_QUEUE_SIZE);
+	options.setDefaultUint("stat_throttle_rate", DEFAULT_STAT_THROTTLE_RATE);
 	options.setDefault("server_software", SERVER_TOKEN_NAME "/" PASSENGER_VERSION);
 	options.setDefaultBool("show_version_in_header", true);
 	options.setDefaultBool("sticky_sessions", false);
@@ -1155,6 +1158,14 @@ sanityCheckOptions() {
 			ok = false;
 		#endif
 	}
+	if (options.has("memory_limit")) {
+		#ifndef PASSENGER_IS_ENTERPRISE
+			fprintf(stderr, "ERROR: the --memory-limit option is only supported in "
+				PROGRAM_NAME " Enterprise.\nYou are currently using the open source "
+				PROGRAM_NAME ". Buy " PROGRAM_NAME " Enterprise here: https://www.phusionpassenger.com/enterprise\n");
+			ok = false;
+		#endif
+	}
 	if (options.has("max_request_time")) {
 		if (options.getInt("max_request_time", false, 0) < 1) {
 			fprintf(stderr, "ERROR: the value passed to --max-request-time must be at least 1.\n");
@@ -1167,8 +1178,8 @@ sanityCheckOptions() {
 			ok = false;
 		#endif
 	}
-	if (RequestHandler::parseBenchmarkMode(options.get("benchmark_mode", false))
-		== RequestHandler::BM_UNKNOWN)
+	if (Core::Controller::parseBenchmarkMode(options.get("benchmark_mode", false))
+		== Core::Controller::BM_UNKNOWN)
 	{
 		fprintf(stderr, "ERROR: '%s' is not a valid mode for --benchmark.\n",
 			options.get("benchmark_mode", false).c_str());