passenger 5.1.4 → 5.1.5

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

@@ -34,5 +34,5 @@
 #include <Core/Controller/InitializationAndShutdown.cpp>
 #include <Core/Controller/InternalUtils.cpp>
 #include <Core/Controller/Miscellaneous.cpp>
-#include <Core/Controller/StateInspectionAndConfiguration.cpp>
+#include <Core/Controller/StateInspection.cpp>
 

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

@@ -136,7 +136,7 @@ void
 Controller::initializePoolOptions(Client *client, Request *req, RequestAnalysis &analysis) {
 	boost::shared_ptr<Options> *options;
 
-	if (singleAppMode) {
+	if (req->configCache->singleAppMode) {
 		P_ASSERT_EQ(poolOptionsCache.size(), 1);
 		poolOptionsCache.lookupRandom(NULL, &options);
 		req->options = **options;
@@ -177,42 +177,31 @@ Controller::initializePoolOptions(Client *client, Request *req, RequestAnalysis
 }
 
 void
-Controller::fillPoolOptionsFromAgentsOptions(Options &options) {
-	options.ruby = defaultRuby;
-	if (agentsOptions->has("default_nodejs")) {
-		options.nodejs = agentsOptions->get("default_nodejs");
-	}
-	if (agentsOptions->has("default_python")) {
-		options.python = agentsOptions->get("default_python");
-	}
-	if (agentsOptions->has("meteor_app_settings")) {
-		options.meteorAppSettings = agentsOptions->get("meteor_app_settings");
-	}
-	if (agentsOptions->has("app_file_descriptor_ulimit")) {
-		options.fileDescriptorUlimit = agentsOptions->getUint("app_file_descriptor_ulimit");
-	}
+Controller::fillPoolOptionsFromConfigCaches(Options &options,
+	const ControllerRequestConfigCachePtr &requestConfigCache)
+{
+	options.ruby = requestConfigCache->defaultRuby;
+	options.nodejs = requestConfigCache->defaultNodejs;
+	options.python = requestConfigCache->defaultPython;
+	options.meteorAppSettings = requestConfigCache->meteorAppSettings;
+	options.fileDescriptorUlimit = requestConfigCache->fileDescriptorUlimit;
 
 	options.logLevel = getLogLevel();
-	options.integrationMode = agentsOptions->get("integration_mode",
-		false, DEFAULT_INTEGRATION_MODE);
-	options.ustRouterAddress = ustRouterAddress;
+	options.integrationMode = mainConfigCache.integrationMode;
+	options.ustRouterAddress = requestConfigCache->ustRouterAddress;
 	options.ustRouterUsername = P_STATIC_STRING("logging");
-	options.ustRouterPassword = ustRouterPassword;
-	options.userSwitching = agentsOptions->getBool("user_switching");
-	if (agentsOptions->has("default_user")) {
-		options.defaultUser = agentsOptions->get("default_user");
-	}
-	if (agentsOptions->has("default_group")) {
-		options.defaultGroup = agentsOptions->get("default_group");
-	}
-	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;
+	options.ustRouterPassword = requestConfigCache->ustRouterPassword;
+	options.userSwitching = mainConfigCache.userSwitching;
+	options.defaultUser = requestConfigCache->defaultUser;
+	options.defaultGroup = requestConfigCache->defaultGroup;
+	options.minProcesses = requestConfigCache->minInstances;
+	options.maxPreloaderIdleTime = requestConfigCache->maxPreloaderIdleTime;
+	options.maxRequestQueueSize = requestConfigCache->maxRequestQueueSize;
+	options.abortWebsocketsOnProcessShutdown = requestConfigCache->abortWebsocketsOnProcessShutdown;
+	options.forceMaxConcurrentRequestsPerProcess = requestConfigCache->forceMaxConcurrentRequestsPerProcess;
+	options.spawnMethod = requestConfigCache->spawnMethod;
+	options.loadShellEnvvars = requestConfigCache->loadShellEnvvars;
+	options.statThrottleRate = mainConfigCache.statThrottleRate;
 
 	/******************************/
 }
@@ -344,7 +333,7 @@ Controller::createNewPoolOptions(Client *client, Request *req,
 		options.baseURI = StaticString(scriptName->start->data, scriptName->size);
 	}
 
-	fillPoolOptionsFromAgentsOptions(options);
+	fillPoolOptionsFromConfigCaches(options, req->configCache);
 
 	const LString *appType = secureHeaders.lookup("!~PASSENGER_APP_TYPE");
 	if (appType == NULL || appType->size == 0) {
@@ -457,7 +446,7 @@ 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,
-			defaultStickySessionsCookieName);
+			req->configCache->defaultStickySessionsCookieName);
 	} else {
 		return value;
 	}
@@ -482,15 +471,15 @@ Controller::onRequestBegin(Client *client, Request *req) {
 		// and localize them as much as possible, for better CPU caching.
 		RequestAnalysis analysis;
 		analysis.flags = req->secureHeaders.lookup(FLAGS);
-		analysis.appGroupNameCell = singleAppMode
+		analysis.appGroupNameCell = req->configCache->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);
+			mainConfigCache.stickySessions);
 		req->showVersionInHeader = getBoolOption(req, PASSENGER_SHOW_VERSION_IN_HEADER,
-			this->showVersionInHeader);
+			req->configCache->showVersionInHeader);
 		req->host = req->headers.lookup(HTTP_HOST);
 
 		/***************/

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

@@ -45,20 +45,12 @@ using namespace boost;
  ****************************/
 
 
-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)),
+Controller::Controller(ServerKit::Context *context, const ControllerSchema &schema,
+	const Json::Value &initialConfig)
+	: ParentClass(context, schema, initialConfig),
+
+	  mainConfigCache(config),
+	  requestConfigCache(new ControllerRequestConfigCache(config)),
 	  poolOptionsCache(4),
 
 	  PASSENGER_APP_GROUP_NAME("!~PASSENGER_APP_GROUP_NAME"),
@@ -83,52 +75,10 @@ Controller::Controller(ServerKit::Context *context, const VariantMap *_agentsOpt
 	  HTTP_STATUS("status"),
 	  HTTP_TRANSFER_ENCODING("transfer-encoding"),
 
-	  threadNumber(_threadNumber),
-	  turboCaching(getTurboCachingInitialState(_agentsOptions))
+	  turboCaching(),
+	  resourceLocator(NULL)
+	  /**************************/
 {
-	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);
@@ -145,7 +95,6 @@ Controller::Controller(ServerKit::Context *context, const VariantMap *_agentsOpt
 
 Controller::~Controller() {
 	ev_check_stop(getLoop(), &checkWatcher);
-	psg_destroy_pool(stringPool);
 }
 
 void
@@ -160,6 +109,22 @@ Controller::initialize() {
 	if (unionStationContext == NULL) {
 		unionStationContext = appPool->getUnionStationContext();
 	}
+
+	ParentClass::initialize();
+	turboCaching.initialize(config["turbocaching"].asBool());
+	getContext()->defaultFileBufferedChannelConfig.bufferDir =
+		config["data_buffer_dir"].asString();
+
+	if (requestConfigCache->singleAppMode) {
+		boost::shared_ptr<Options> options = boost::make_shared<Options>();
+		fillPoolOptionsFromConfigCaches(*options, requestConfigCache);
+		options->appRoot = config["app_root"].asString();
+		options->environment = config["environment"].asString();
+		options->appType = config["app_type"].asString();
+		options->startupFile = config["startup_file"].asString();
+		*options = options->copyAndPersist();
+		poolOptionsCache.insert(options->getAppGroupName(), options);
+	}
 }
 
 

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

@@ -45,22 +45,6 @@ using namespace boost;
  ****************************/
 
 
-TurboCaching<Request>::State
-Controller::getTurboCachingInitialState(const VariantMap *agentsOptions) {
-	bool enabled = agentsOptions->getBool("turbocaching", false, true);
-	if (enabled) {
-		return TurboCaching<Request>::ENABLED;
-	} else {
-		return TurboCaching<Request>::DISABLED;
-	}
-}
-
-void
-Controller::generateServerLogName(unsigned int number) {
-	string name = "ServerThr." + toString(number);
-	serverLogName = psg_pstrdup(stringPool, name);
-}
-
 void
 Controller::disconnectWithClientSocketWriteError(Client **client, int e) {
 	stringstream message;

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

@@ -94,23 +94,6 @@ Controller::disconnectLongRunningConnections(const StaticString &gupid) {
 	}
 }
 
-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

data/src/agent/Core/Controller/Request.h

@@ -38,6 +38,7 @@
 #include <Core/UnionStation/Context.h>
 #include <Core/UnionStation/Transaction.h>
 #include <Core/UnionStation/StopwatchLog.h>
+#include <Core/Controller/Config.h>
 #include <Core/Controller/AppResponse.h>
 
 namespace Passenger {
@@ -85,6 +86,7 @@ public:
 	Options options;
 	AbstractSessionPtr session;
 	const LString *host;
+	ControllerRequestConfigCachePtr configCache;
 
 	ServerKit::FdSinkChannel appSink;
 	ServerKit::FdSourceChannel appSource;

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

@@ -393,8 +393,8 @@ Controller::determineHeaderSizeForSessionProtocol(Request *req,
 			}
 		}
 	} else {
-		state.serverName = defaultServerName;
-		state.serverPort = defaultServerPort;
+		state.serverName = req->configCache->defaultServerName;
+		state.serverPort = req->configCache->defaultServerPort;
 	}
 
 	dataSize += sizeof("SERVER_NAME");
@@ -404,7 +404,7 @@ Controller::determineHeaderSizeForSessionProtocol(Request *req,
 	dataSize += state.serverPort.size() + 1;
 
 	dataSize += sizeof("SERVER_SOFTWARE");
-	dataSize += serverSoftware.size() + 1;
+	dataSize += req->configCache->serverSoftware.size() + 1;
 
 	dataSize += sizeof("SERVER_PROTOCOL");
 	dataSize += sizeof("HTTP/1.1");
@@ -515,7 +515,7 @@ Controller::constructHeaderForSessionProtocol(Request *req, char * restrict buff
 	pos = appendData(pos, end, "", 1);
 
 	pos = appendData(pos, end, P_STATIC_STRING_WITH_NULL("SERVER_SOFTWARE"));
-	pos = appendData(pos, end, serverSoftware);
+	pos = appendData(pos, end, req->configCache->serverSoftware);
 	pos = appendData(pos, end, "", 1);
 
 	pos = appendData(pos, end, P_STATIC_STRING_WITH_NULL("SERVER_PROTOCOL"));

data/src/agent/Core/Controller/{StateInspectionAndConfiguration.cpp → StateInspection.cpp}

@@ -46,28 +46,6 @@ using namespace boost;
  ****************************/
 
 
-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();

data/src/agent/Core/Controller/TurboCaching.h

@@ -113,7 +113,7 @@ private:
 
 		prep.ageValueSize = integerSizeInOtherBase<time_t, 10>(prep.age);
 		prep.contentLengthStrSize = uintSizeAsString(entry.body->httpBodySize);
-		prep.showVersionInHeader = server->showVersionInHeader;
+		prep.showVersionInHeader = req->configCache->showVersionInHeader;
 	}
 
 	template<typename Server>
@@ -192,15 +192,16 @@ private:
 public:
 	ResponseCache<Request> responseCache;
 
-	TurboCaching(State initialState = ENABLED)
-		: state(initialState),
-		  lastTimeout((ev_tstamp) time(NULL)),
-		  nextTimeout((ev_tstamp) time(NULL) + ENABLED_TIMEOUT)
-	{
-		if (initialState != ENABLED && initialState != DISABLED) {
-			throw RuntimeException("The initial turbocaching state may "
-				"only be ENABLED or DISABLED");
-		}
+	TurboCaching()
+		: state(ENABLED),
+		  lastTimeout(0),
+		  nextTimeout(0)
+		{ }
+
+	void initialize(bool initiallyEnabled) {
+		state = initiallyEnabled ? ENABLED : DISABLED;
+		lastTimeout = (ev_tstamp) time(NULL);
+		nextTimeout = (ev_tstamp) time(NULL) + ENABLED_TIMEOUT;
 	}
 
 	bool isEnabled() const {

data/src/agent/Core/CoreMain.cpp

@@ -76,6 +76,7 @@
 #include <Constants.h>
 #include <ServerKit/Server.h>
 #include <ServerKit/AcceptLoadBalancer.h>
+#include <ConfigKit/VariantMapUtils.h>
 #include <MessageReadersWriters.h>
 #include <FileDescriptor.h>
 #include <ResourceLocator.h>
@@ -118,6 +119,7 @@ namespace Core {
 	struct ApiWorkingObjects {
 		BackgroundEventLoop *bgloop;
 		ServerKit::Context *serverKitContext;
+		ServerKit::HttpServerSchema apiServerSchema;
 		ApiServer::ApiServer *apiServer;
 
 		ApiWorkingObjects()
@@ -141,6 +143,7 @@ namespace Core {
 		PoolPtr appPool;
 
 		ServerKit::AcceptLoadBalancer<Controller> loadBalancer;
+		ControllerSchema controllerSchema;
 		vector<ThreadWorkingObjects> threadWorkingObjects;
 		struct ev_signal sigintWatcher;
 		struct ev_signal sigtermWatcher;
@@ -461,7 +464,7 @@ inspectControllerStateAsJson(Controller *controller, string *result) {
 
 static void
 inspectControllerConfigAsJson(Controller *controller, string *result) {
-	*result = controller->getConfigAsJson().toStyledString();
+	*result = controller->inspectConfig().toStyledString();
 }
 
 static void
@@ -541,7 +544,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->controller->getConfigAsJson();
+		cerr << two->controller->inspectConfig();
 		cerr << "\n";
 		cerr.flush();
 	}
@@ -672,6 +675,10 @@ initializeNonPrivilegedWorkingObjects() {
 		UPDATE_TRACE_POINT();
 		ThreadWorkingObjects two;
 
+		Json::Value config = ConfigKit::variantMapToJson(wo->controllerSchema,
+			*agentsOptions);
+		config["thread_number"] = i + 1;
+
 		if (i == 0) {
 			two.bgloop = firstLoop = new BackgroundEventLoop(true, true);
 		} else {
@@ -688,7 +695,8 @@ initializeNonPrivilegedWorkingObjects() {
 			options.getUint("file_buffer_threshold");
 
 		UPDATE_TRACE_POINT();
-		two.controller = new Core::Controller(two.serverKitContext, agentsOptions, i + 1);
+		two.controller = new Core::Controller(two.serverKitContext,
+			wo->controllerSchema, config);
 		two.controller->minSpareClients = 128;
 		two.controller->clientFreelistLimit = 1024;
 		two.controller->resourceLocator = &wo->resourceLocator;
@@ -724,7 +732,8 @@ initializeNonPrivilegedWorkingObjects() {
 			options.getUint("file_buffer_threshold");
 
 		UPDATE_TRACE_POINT();
-		awo->apiServer = new Core::ApiServer::ApiServer(awo->serverKitContext);
+		awo->apiServer = new Core::ApiServer::ApiServer(awo->serverKitContext,
+			awo->apiServerSchema);
 		awo->apiServer->controllers.reserve(wo->threadWorkingObjects.size());
 		for (unsigned int i = 0; i < wo->threadWorkingObjects.size(); i++) {
 			awo->apiServer->controllers.push_back(
@@ -736,6 +745,7 @@ initializeNonPrivilegedWorkingObjects() {
 		awo->apiServer->fdPassingPassword = options.get("watchdog_fd_passing_password", false);
 		awo->apiServer->exitEvent = &wo->exitEvent;
 		awo->apiServer->shutdownFinishCallback = apiServerShutdownFinished;
+		awo->apiServer->initialize();
 
 		wo->shutdownCounter.fetch_add(1, boost::memory_order_relaxed);
 	}
@@ -1305,8 +1315,8 @@ sanityCheckOptions() {
 			ok = false;
 		#endif
 	}
-	if (Core::Controller::parseBenchmarkMode(options.get("benchmark_mode", false))
-		== Core::Controller::BM_UNKNOWN)
+	if (Core::parseControllerBenchmarkMode(options.get("benchmark_mode", false))
+		== Core::BM_UNKNOWN)
 	{
 		fprintf(stderr, "ERROR: '%s' is not a valid mode for --benchmark.\n",
 			options.get("benchmark_mode", false).c_str());