passenger 5.1.12 → 5.2.0

data/src/agent/Core/ApiServer.h

@@ -26,6 +26,8 @@
 #ifndef _PASSENGER_CORE_API_SERVER_H_
 #define _PASSENGER_CORE_API_SERVER_H_
 
+#include <boost/config.hpp>
+#include <boost/scoped_ptr.hpp>
 #include <boost/regex.hpp>
 #include <oxt/thread.hpp>
 #include <string>
@@ -37,8 +39,10 @@
 #include <modp_b64.h>
 
 #include <Core/Controller.h>
+#include <Core/ConfigChange.h>
 #include <Core/ApplicationPool/Pool.h>
 #include <Shared/ApiServerUtils.h>
+#include <Shared/ApiAccountUtils.h>
 #include <ServerKit/HttpServer.h>
 #include <DataStructures/LString.h>
 #include <Exceptions.h>
@@ -57,6 +61,55 @@ namespace ApiServer {
 using namespace std;
 
 
+/*
+ * BEGIN ConfigKit schema: Passenger::Core::ApiServer::Schema
+ * (do not edit: following text is automatically generated
+ * by 'rake configkit_schemas_inline_comments')
+ *
+ *   accept_burst_count             unsigned integer   -   default(32)
+ *   authorizations                 array              -   default("[FILTERED]"),secret
+ *   client_freelist_limit          unsigned integer   -   default(0)
+ *   instance_dir                   string             -   -
+ *   min_spare_clients              unsigned integer   -   default(0)
+ *   request_freelist_limit         unsigned integer   -   default(1024)
+ *   start_reading_after_accept     boolean            -   default(true)
+ *   watchdog_fd_passing_password   string             -   secret
+ *
+ * END
+ */
+class Schema: public ServerKit::HttpServerSchema {
+private:
+	static Json::Value normalizeAuthorizations(const Json::Value &effectiveValues) {
+		Json::Value updates;
+		updates["authorizations"] = ApiAccountUtils::normalizeApiAccountsJson(
+			effectiveValues["authorizations"]);
+		return updates;
+	}
+
+public:
+	Schema()
+		: ServerKit::HttpServerSchema(false)
+	{
+		using namespace ConfigKit;
+
+		add("instance_dir", STRING_TYPE, OPTIONAL);
+		add("watchdog_fd_passing_password", STRING_TYPE, OPTIONAL | SECRET);
+		add("authorizations", ARRAY_TYPE, OPTIONAL | SECRET, Json::arrayValue);
+
+		addValidator(boost::bind(ApiAccountUtils::validateAuthorizationsField,
+			"authorizations", boost::placeholders::_1, boost::placeholders::_2));
+
+		addNormalizer(normalizeAuthorizations);
+
+		finalize();
+	}
+};
+
+struct ConfigChangeRequest {
+	ServerKit::HttpServerConfigChangeRequest forParent;
+	boost::scoped_ptr<ApiAccountUtils::ApiAccountDatabase> apiAccountDatabase;
+};
+
 class Request: public ServerKit::BaseHttpRequest {
 public:
 	string body;
@@ -69,11 +122,15 @@ public:
 };
 
 class ApiServer: public ServerKit::HttpServer<ApiServer, ServerKit::HttpClient<Request> > {
-private:
+public:
 	typedef ServerKit::HttpServer<ApiServer, ServerKit::HttpClient<Request> > ParentClass;
 	typedef ServerKit::HttpClient<Request> Client;
 	typedef ServerKit::HeaderTable HeaderTable;
 
+	typedef Passenger::Core::ApiServer::ConfigChangeRequest ConfigChangeRequest;
+
+private:
+	ApiAccountUtils::ApiAccountDatabase apiAccountDatabase;
 	boost::regex serverConnectionPath;
 
 	bool regex_match(const StaticString &str, const boost::regex &e) const {
@@ -127,7 +184,8 @@ private:
 			processConfig(client, req);
 		} else if (path == P_STATIC_STRING("/reinherit_logs.json")) {
 			apiServerProcessReinheritLogs(this, client, req,
-				instanceDir, fdPassingPassword);
+				config["instance_dir"].asString(),
+				config["watchdog_fd_passing_password"].asString());
 		} else if (path == P_STATIC_STRING("/reopen_logs.json")) {
 			apiServerProcessReopenLogs(this, client, req);
 		} else {
@@ -440,12 +498,16 @@ private:
 		if (req->method == HTTP_GET) {
 			if (!authorizeStateInspectionOperation(this, client, req)) {
 				apiServerRespondWith401(this, client, req);
+				return;
 			}
 
-			refRequest(req, __FILE__, __LINE__);
-			controllers[0]->getContext()->libev->runLater(boost::bind(
-				&ApiServer::processConfig_getControllerConfig, this,
-				client, req, controllers[0]));
+			HeaderTable headers;
+			headers.insert(req->pool, "Content-Type", "application/json");
+			writeSimpleResponse(client, 200, &headers,
+				psg_pstrdup(req->pool, Core::inspectConfig().toStyledString()));
+			if (!req->ended()) {
+				endRequest(&client, &req);
+			}
 		} else if (req->method == HTTP_PUT) {
 			if (!authorizeAdminOperation(this, client, req)) {
 				apiServerRespondWith401(this, client, req);
@@ -458,110 +520,78 @@ private:
 		}
 	}
 
-	void processConfig_getControllerConfig(Client *client, Request *req,
-		Controller *controller)
+	void processConfigBody(Client *client, Request *req) {
+		Core::ConfigChangeRequest *changeReq = Core::createConfigChangeRequest();
+		refRequest(req, __FILE__, __LINE__);
+		Core::asyncPrepareConfigChange(req->jsonBody, changeReq,
+			boost::bind(&ApiServer::processConfigBody_prepareDone, this, client, req,
+				boost::placeholders::_1, boost::placeholders::_2));
+	}
+
+	void processConfigBody_prepareDone(Client *client, Request *req,
+		const vector<ConfigKit::Error> &errors, Core::ConfigChangeRequest *changeReq)
 	{
-		Json::Value config = controller->inspectConfig();
-		getContext()->libev->runLater(boost::bind(
-			&ApiServer::processConfig_controllerConfigGathered, this,
-			client, req, controller, config));
+		getContext()->libev->runLater(boost::bind(&ApiServer::processConfigBody_prepareDoneInEventLoop,
+			this, client, req, errors, changeReq));
 	}
 
-	void processConfig_controllerConfigGathered(Client *client, Request *req,
-		Controller *controller, Json::Value config)
+	void processConfigBody_prepareDoneInEventLoop(Client *client, Request *req,
+		const vector<ConfigKit::Error> &errors, Core::ConfigChangeRequest *changeReq)
 	{
 		if (req->ended()) {
+			Core::freeConfigChangeRequest(changeReq);
 			unrefRequest(req, __FILE__, __LINE__);
 			return;
 		}
 
-		HeaderTable headers;
-		ConfigKit::Store loggingConfig = LoggingKit::context->getConfig();
-
-		headers.insert(req->pool, "Content-Type", "application/json");
-		config["log_level"] = (int) LoggingKit::parseLevel(loggingConfig["level"].asString());
-		if (loggingConfig["target"].isMember("path")) {
-			config["log_file"] = loggingConfig["target"]["path"].asString();
-		}
-		if (!loggingConfig["file_descriptor_log_target"].isNull()
-			&& loggingConfig["file_descriptor_log_target"].isMember("path"))
-		{
-			config["file_descriptor_log_file"] =
-				loggingConfig["file_descriptor_log_target"]["path"].asString();
-		}
-
-		writeSimpleResponse(client, 200, &headers,
-			psg_pstrdup(req->pool, config.toStyledString()));
-		if (!req->ended()) {
-			Request *req2 = req;
-			endRequest(&client, &req2);
-		}
-
-		unrefRequest(req, __FILE__, __LINE__);
-	}
-
-	static void configureController(Controller *controller, Json::Value updates) {
-		vector<ConfigKit::Error> errors;
-		ControllerConfigChangeRequest req;
-
-		if (controller->prepareConfigChange(updates, errors, req)) {
-			controller->commitConfigChange(req);
+		if (errors.empty()) {
+			Core::asyncCommitConfigChange(changeReq,
+				boost::bind(&ApiServer::processConfigBody_commitDone, this, client, req,
+					boost::placeholders::_1));
 		} else {
-			P_ERROR("Unable to apply configuration change to Core controller.\n"
-				"Configuration: " << updates.toStyledString() << "\n"
-				"Errors: " << toString(errors));
-		}
-	}
-
-	void processConfigBody(Client *client, Request *req) {
-		HeaderTable headers;
-		LoggingKit::ConfigChangeRequest configReq;
-		const Json::Value &json = req->jsonBody;
-		vector<ConfigKit::Error> errors;
-		bool ok;
-
-		headers.insert(req->pool, "Content-Type", "application/json");
-		headers.insert(req->pool, "Cache-Control", "no-cache, no-store, must-revalidate");
-
-		try {
-			ok = LoggingKit::context->prepareConfigChange(json,
-				errors, configReq);
-		} catch (const std::exception &e) {
-			unsigned int bufsize = 2048;
-			char *message = (char *) psg_pnalloc(req->pool, bufsize);
-			snprintf(message, bufsize, "{ \"status\": \"error\", "
-				"\"message\": \"Error reconfiguring logging system: %s\" }",
-				e.what());
-			writeSimpleResponse(client, 500, &headers, message);
-			if (!req->ended()) {
-				endRequest(&client, &req);
-			}
-			return;
-		}
-		if (!ok) {
 			unsigned int bufsize = 2048;
 			char *message = (char *) psg_pnalloc(req->pool, bufsize);
 			snprintf(message, bufsize, "{ \"status\": \"error\", "
-				"\"message\": \"Error reconfiguring logging system: %s\" }",
+				"\"message\": \"Error reconfiguring: %s\" }",
 				ConfigKit::toString(errors).c_str());
+
+			HeaderTable headers;
+			headers.insert(req->pool, "Content-Type", "application/json");
+			headers.insert(req->pool, "Cache-Control", "no-cache, no-store, must-revalidate");
 			writeSimpleResponse(client, 500, &headers, message);
+
 			if (!req->ended()) {
-				endRequest(&client, &req);
+				Request *req2 = req;
+				endRequest(&client, &req2);
 			}
-			return;
-		}
 
-		LoggingKit::context->commitConfigChange(configReq);
-
-		for (unsigned int i = 0; i < controllers.size(); i++) {
-			controllers[i]->getContext()->libev->runLater(boost::bind(
-				configureController, controllers[i], json));
+			Core::freeConfigChangeRequest(changeReq);
+			unrefRequest(req, __FILE__, __LINE__);
 		}
+	}
+
+	void processConfigBody_commitDone(Client *client, Request *req,
+		Core::ConfigChangeRequest *changeReq)
+	{
+		getContext()->libev->runLater(boost::bind(&ApiServer::processConfigBody_commitDoneInEventLoop,
+			this, client, req, changeReq));
+	}
 
-		writeSimpleResponse(client, 200, &headers, "{ \"status\": \"ok\" }");
+	void processConfigBody_commitDoneInEventLoop(Client *client, Request *req,
+		Core::ConfigChangeRequest *changeReq)
+	{
 		if (!req->ended()) {
-			endRequest(&client, &req);
+			HeaderTable headers;
+			headers.insert(req->pool, "Content-Type", "application/json");
+			headers.insert(req->pool, "Cache-Control", "no-cache, no-store, must-revalidate");
+			writeSimpleResponse(client, 200, &headers, "{ \"status\": \"ok\" }");
+			if (!req->ended()) {
+				Request *req2 = req;
+				endRequest(&client, &req2);
+			}
 		}
+		Core::freeConfigChangeRequest(changeReq);
+		unrefRequest(req, __FILE__, __LINE__);
 	}
 
 	bool requestBodyExceedsLimit(Client *client, Request *req, unsigned int limit = 1024 * 128) {
@@ -648,21 +678,33 @@ protected:
 	}
 
 public:
+	typedef ApiAccountUtils::ApiAccount ApiAccount;
+
+	// Dependencies
 	vector<Controller *> controllers;
-	ApiAccountDatabase *apiAccountDatabase;
 	ApplicationPool2::PoolPtr appPool;
-	string instanceDir;
-	string fdPassingPassword;
 	EventFd *exitEvent;
-	vector<Authorization> authorizations;
 
-	ApiServer(ServerKit::Context *context, const ServerKit::HttpServerSchema &schema,
-		const Json::Value &initialConfig = Json::Value())
-		: ParentClass(context, schema, initialConfig),
+	ApiServer(ServerKit::Context *context, const Schema &schema,
+		const Json::Value &initialConfig,
+		const ConfigKit::Translator &translator = ConfigKit::DummyTranslator())
+		: ParentClass(context, schema, initialConfig, translator),
 		  serverConnectionPath("^/server/(.+)\\.json$"),
-		  apiAccountDatabase(NULL),
 		  exitEvent(NULL)
-		{ }
+	{
+		apiAccountDatabase = ApiAccountUtils::ApiAccountDatabase(
+			config["authorizations"]);
+	}
+
+	virtual void initialize() {
+		if (appPool == NULL) {
+			throw RuntimeException("appPool must be non-NULL");
+		}
+		if (exitEvent == NULL) {
+			throw RuntimeException("exitEvent must be non-NULL");
+		}
+		ParentClass::initialize();
+	}
 
 	virtual StaticString getServerName() const {
 		return P_STATIC_STRING("ApiServer");
@@ -677,6 +719,10 @@ public:
 		return pos - buf;
 	}
 
+	const ApiAccountUtils::ApiAccountDatabase &getApiAccountDatabase() const {
+		return apiAccountDatabase;
+	}
+
 	bool authorizeByUid(uid_t uid) const {
 		return appPool->authorizeByUid(uid);
 	}
@@ -684,6 +730,22 @@ public:
 	bool authorizeByApiKey(const ApplicationPool2::ApiKey &apiKey) const {
 		return appPool->authorizeByApiKey(apiKey);
 	}
+
+
+	bool prepareConfigChange(const Json::Value &updates,
+		vector<ConfigKit::Error> &errors, ConfigChangeRequest &req)
+	{
+		if (ParentClass::prepareConfigChange(updates, errors, req.forParent)) {
+			req.apiAccountDatabase.reset(new ApiAccountUtils::ApiAccountDatabase(
+				req.forParent.forParent.config->get("authorizations")));
+		}
+		return errors.empty();
+	}
+
+	void commitConfigChange(ConfigChangeRequest &req) BOOST_NOEXCEPT_OR_NOTHROW {
+		ParentClass::commitConfigChange(req.forParent);
+		apiAccountDatabase.swap(*req.apiAccountDatabase);
+	}
 };
 
 

data/src/agent/Core/ApplicationPool/Group.h

@@ -478,6 +478,8 @@ public:
 	bool garbageCollectable(unsigned long long now = 0) const;
 
 	void inspectXml(std::ostream &stream, bool includeSecrets = true) const;
+	void inspectPropertiesInAdminPanelFormat(Json::Value &result) const;
+	void inspectConfigInAdminPanelFormat(Json::Value &result) const;
 
 	/****** Out-of-band work ******/
 

data/src/agent/Core/ApplicationPool/Group/InternalUtils.cpp

@@ -98,13 +98,14 @@ Group::mergeOptions(const Options &other) {
 bool
 Group::prepareHookScriptOptions(HookScriptOptions &hsOptions, const char *name) {
 	SpawningKit::ConfigPtr config = getPool()->getSpawningKitConfig();
-	if (config->agentsOptions == NULL) {
+	LockGuard l(config->agentConfigSyncher);
+	if (config->agentConfig.isNull()) {
 		return false;
 	}
 
 	hsOptions.name = name;
 	string hookName = string("hook_") + name;
-	hsOptions.spec = config->agentsOptions->get(hookName, false);
+	hsOptions.spec = config->agentConfig.get(hookName, Json::Value()).asString();
 
 	return true;
 }

data/src/agent/Core/ApplicationPool/Group/StateInspection.cpp

@@ -24,6 +24,9 @@
  *  THE SOFTWARE.
  */
 #include <Core/ApplicationPool/Group.h>
+#include <FileTools/PathManip.h>
+#include <cassert>
+#include <modp_b64.h>
 
 /*************************************************************************
  *
@@ -193,6 +196,112 @@ Group::inspectXml(std::ostream &stream, bool includeSecrets) const {
 	stream << "</processes>";
 }
 
+void
+Group::inspectPropertiesInAdminPanelFormat(Json::Value &result) const {
+	result["path"] = absolutizePath(options.appRoot);
+	result["startup_file"] = absolutizePath(options.getStartupFile(), absolutizePath(options.appRoot));
+	result["start_command"] = options.getStartCommand(getResourceLocator());
+
+	if (options.appType == "rack") {
+		result["type"] = "ruby";
+	} else if (options.appType == "wsgi") {
+		result["type"] = "python";
+	} else if (options.appType == "node") {
+		result["type"] = "nodejs";
+	} else if (options.appType == "meteor") {
+		result["type"] = "meteor";
+	} else {
+		result["type"] = "generic";
+	}
+
+	SpawningKit::UserSwitchingInfo usInfo(SpawningKit::prepareUserSwitching(options));
+	result["user"]["username"] = usInfo.username;
+	result["user"]["uid"] = (Json::Int) usInfo.uid;
+	result["group"]["groupname"] = usInfo.groupname;
+	result["group"]["gid"] = (Json::Int) usInfo.gid;
+
+	/******************/
+}
+
+void
+Group::inspectConfigInAdminPanelFormat(Json::Value &result) const {
+	#define VAL Pool::makeSingleValueJsonConfigFormat
+	#define SVAL Pool::makeSingleStrValueJsonConfigFormat
+	#define NON_EMPTY_SVAL Pool::makeSingleNonEmptyStrValueJsonConfigFormat
+
+	result["app_root"] = NON_EMPTY_SVAL(absolutizePath(options.appRoot));
+	result["app_group_name"] = NON_EMPTY_SVAL(info.name);
+	result["default_user"] = NON_EMPTY_SVAL(options.defaultUser);
+	result["default_group"] = NON_EMPTY_SVAL(options.defaultGroup);
+	result["enabled"] = VAL(true, false);
+	result["lve_min_uid"] = VAL(options.lveMinUid, DEFAULT_LVE_MIN_UID);
+
+	result["type"] = NON_EMPTY_SVAL(options.appType);
+	result["startup_file"] = NON_EMPTY_SVAL(options.startupFile);
+	result["start_command"] = NON_EMPTY_SVAL(replaceAll(options.startCommand,
+		P_STATIC_STRING("\t"), P_STATIC_STRING(" ")));
+	result["ruby"] = SVAL(options.ruby, DEFAULT_RUBY);
+	result["python"] = SVAL(options.python, DEFAULT_PYTHON);
+	result["nodejs"] = SVAL(options.nodejs, DEFAULT_NODEJS);
+	result["meteor_app_settings"] = NON_EMPTY_SVAL(options.meteorAppSettings);
+	result["min_processes"] = VAL(options.minProcesses, 1u);
+	result["max_processes"] = VAL(options.maxProcesses, 0u);
+	result["environment"] = SVAL(options.environment); // TODO: default value depends on integration mode
+	result["spawn_method"] = SVAL(options.spawnMethod, DEFAULT_SPAWN_METHOD);
+	result["start_timeout"] = VAL(options.startTimeout / 1000.0, DEFAULT_START_TIMEOUT / 1000.0);
+	result["max_preloader_idle_time"] = VAL((Json::UInt) options.maxPreloaderIdleTime,
+		(Json::UInt) DEFAULT_MAX_PRELOADER_IDLE_TIME);
+	result["max_out_of_band_work_instances"] = VAL(options.maxOutOfBandWorkInstances,
+		(Json::UInt) 1);
+	result["base_uri"] = SVAL(options.baseURI, P_STATIC_STRING("/"));
+	result["user"] = SVAL(options.user, options.defaultUser);
+	result["group"] = SVAL(options.group, options.defaultGroup);
+	result["user_switching"] = VAL(options.userSwitching); // TODO: default value depends on integration mode and euid
+	result["file_descriptor_ulimit"] = VAL(options.fileDescriptorUlimit, 0u);
+	result["load_shell_envvars"] = VAL(options.loadShellEnvvars); // TODO: default value depends on integration mode
+	result["max_request_queue_size"] = VAL(options.maxRequestQueueSize,
+		(Json::UInt) DEFAULT_MAX_REQUEST_QUEUE_SIZE);
+	result["max_requests"] = VAL((Json::UInt) options.maxRequests, 0u);
+	result["abort_websockets_on_process_shutdown"] = VAL(options.abortWebsocketsOnProcessShutdown);
+	result["force_max_concurrent_requests_per_process"] = VAL(options.forceMaxConcurrentRequestsPerProcess, -1);
+	result["restart_dir"] = NON_EMPTY_SVAL(options.restartDir);
+
+	if (!options.environmentVariables.empty()) {
+		DynamicBuffer envvarsData(options.environmentVariables.size() * 3 / 4);
+		size_t envvarsDataSize = modp_b64_decode(envvarsData.data,
+			options.environmentVariables.data(), options.environmentVariables.size());
+		if (envvarsDataSize == (size_t) -1) {
+			P_WARN("Unable to decode environment variable data");
+		} else {
+			Json::Value envvars(Json::objectValue);
+			vector<string> envvarsAry;
+			unsigned int i;
+
+			split(StaticString(envvarsData.data, envvarsDataSize), '\0', envvarsAry);
+			if (!envvarsAry.empty() && envvarsAry.back().empty()) {
+				envvarsAry.pop_back();
+			}
+			assert(envvars.size() % 2 == 0);
+
+			for (i = 0; i < envvarsAry.size(); i += 2) {
+				envvars[envvarsAry[i]] = envvarsAry[i + 1];
+			}
+
+			result["environment_variables"] = VAL(envvars, Json::objectValue);
+		}
+	} else {
+		result["environment_variables"] = VAL(Json::objectValue, Json::objectValue);
+	}
+
+	// Missing: sticky_sessions, sticky_session_cookie_name, friendly_error_pages
+
+	/******************/
+
+	#undef VAL
+	#undef SVAL
+	#undef NON_EMPTY_SVAL
+}
+
 
 } // namespace ApplicationPool2
 } // namespace Passenger