passenger 5.1.7 → 5.1.8

data/src/agent/UstRouter/Controller.h

@@ -39,7 +39,7 @@
 #include <ServerKit/Server.h>
 #include <StaticString.h>
 #include <Constants.h>
-#include <Logging.h>
+#include <LoggingKit/LoggingKit.h>
 #include <UstRouter/Transaction.h>
 #include <UstRouter/Client.h>
 #include <UstRouter/FileSink.h>
@@ -61,6 +61,61 @@ using namespace oxt;
 
 
 class Controller: public ServerKit::BaseServer<Controller, Client> {
+public:
+	class Schema: public ServerKit::BaseServerSchema {
+	private:
+		static Json::Value getDefaultValueForDefaultNodeName(const ConfigKit::Store &store) {
+			return getHostName();
+		}
+
+	public:
+		Schema()
+			: ServerKit::BaseServerSchema(false)
+		{
+			using namespace ConfigKit;
+
+			add("ust_router_username", STRING_TYPE, OPTIONAL);
+			add("ust_router_password", STRING_TYPE, OPTIONAL);
+			add("ust_router_dump_dir", STRING_TYPE, OPTIONAL, "/tmp");
+			addWithDynamicDefault(
+				"ust_router_default_node_name",
+				STRING_TYPE, OPTIONAL | CACHE_DEFAULT_VALUE,
+				getDefaultValueForDefaultNodeName);
+			add("ust_router_dev_mode", BOOL_TYPE, OPTIONAL, false);
+			add("union_station_gateway_address", STRING_TYPE, OPTIONAL | READ_ONLY, DEFAULT_UNION_STATION_GATEWAY_ADDRESS);
+			add("union_station_gateway_port", UINT_TYPE, OPTIONAL | READ_ONLY, DEFAULT_UNION_STATION_GATEWAY_PORT);
+			add("union_station_gateway_cert", STRING_TYPE, OPTIONAL | READ_ONLY);
+			add("union_station_proxy_address", STRING_TYPE, OPTIONAL | READ_ONLY);
+			add("analytics_sink_flush_timer_interval", UINT_TYPE, OPTIONAL, 5);
+			add("analytics_sink_flush_interval", UINT_TYPE, OPTIONAL, 0);
+
+			finalize();
+		}
+	};
+
+	struct ConfigRealization {
+		bool devMode;
+		unsigned int sinkFlushTimerInterval;
+		unsigned int sinkFlushInterval;
+
+		ConfigRealization(const ConfigKit::Store &config)
+			: devMode(config["ust_router_dev_mode"].asBool()),
+			  sinkFlushTimerInterval(config["analytics_sink_flush_timer_interval"].asUInt()),
+			  sinkFlushInterval(config["analytics_sink_flush_interval"].asUInt())
+			{ }
+
+		void swap(ConfigRealization &other) BOOST_NOEXCEPT_OR_NOTHROW {
+			std::swap(devMode, other.devMode);
+			std::swap(sinkFlushTimerInterval, other.sinkFlushTimerInterval);
+			std::swap(sinkFlushInterval, other.sinkFlushInterval);
+		}
+	};
+
+	struct ConfigChangeRequest {
+		ServerKit::BaseServerConfigChangeRequest forParent;
+		boost::scoped_ptr<ConfigRealization> configRlz;
+	};
+
 private:
 	static const unsigned int GARBAGE_COLLECTION_TIMEOUT = 60; // 1 minute
 	static const unsigned int LOG_SINK_MAX_IDLE_TIME = 5 * 60; // 5 minutes
@@ -77,6 +132,7 @@ private:
 	typedef StringMap<TransactionPtr> TransactionMap;
 	typedef StringMap<LogSinkPtr> LogSinkCache;
 
+	ConfigRealization configRlz;
 	RandomGenerator randomGenerator;
 	TransactionMap transactions;
 	LogSinkCache logSinkCache;
@@ -85,8 +141,6 @@ private:
 
 	ev::timer gcTimer;
 	ev::timer flushTimer;
-	bool devMode;
-	int sinkFlushInterval;
 
 
 	/****** Handshake and authentication ******/
@@ -320,8 +374,9 @@ private:
 	void processLogMessageBody(Client *client, const StaticString &body) {
 		// In here we process the scalar message that's expected to come
 		// after the "log" command.
+		LoggingKit::Level level = LoggingKit::getLevel();
 
-		if (getLogLevel() == LVL_DEBUG) {
+		if (level == LoggingKit::DEBUG) {
 			string truncatedBody;
 			if (body.size() > 97) {
 				string truncatedBody = body.substr(0, 97);
@@ -332,7 +387,7 @@ private:
 				SKC_DEBUG(client, "Processing message body (" << body.size() <<
 					" bytes): " << body);
 			}
-		} else if (getLogLevel() >= LVL_DEBUG2) {
+		} else if (level >= LoggingKit::DEBUG2) {
 			SKC_TRACE(client, 2, "Processing message body (" << body.size() <<
 				" bytes): " << body);
 		}
@@ -687,7 +742,7 @@ private:
 
 		LogSinkCache::iterator it;
 		LogSinkCache::iterator end = logSinkCache.end();
-		ev_tstamp threshold = ev_now(getLoop()) - sinkFlushInterval;
+		ev_tstamp threshold = ev_now(getLoop()) - configRlz.sinkFlushInterval;
 
 		for (it = logSinkCache.begin(); it != end; it++) {
 			const LogSinkPtr &sink = it->second;
@@ -947,7 +1002,7 @@ private:
 	void closeTransaction(Client *client, const TransactionPtr &transaction) {
 		if (!transaction->isDiscarded() && passesFilter(transaction)) {
 			LogSinkPtr logSink;
-			if (devMode) {
+			if (configRlz.devMode) {
 				logSink = openLogFile(client, transaction->getCategory());
 			} else {
 				logSink = openRemoteSink(transaction->getUnionStationKey(),
@@ -1054,16 +1109,6 @@ private:
 		return *filter;
 	}
 
-	void applyConfigUpdates() {
-		devMode = config["ust_router_dev_mode"].asBool();
-
-		unsigned int sinkFlushTimerInterval =
-			config["analytics_sink_flush_timer_interval"].asUInt();
-		sinkFlushInterval = config["analytics_sink_flush_interval"].asUInt();
-		flushTimer.stop();
-		flushTimer.start(sinkFlushTimerInterval, sinkFlushTimerInterval);
-	}
-
 protected:
 	virtual void reinitializeClient(Client *client, int fd) {
 		ParentClass::reinitializeClient(client, fd);
@@ -1135,11 +1180,6 @@ protected:
 		}
 	}
 
-	virtual void onConfigChange(const ConfigKit::Store *oldConfig) {
-		ParentClass::onConfigChange(oldConfig);
-		applyConfigUpdates();
-	}
-
 	virtual void onShutdown(bool forceDisconnect) {
 		gcTimer.stop();
 		flushTimer.stop();
@@ -1147,56 +1187,22 @@ protected:
 	}
 
 public:
-	class Schema: public ServerKit::BaseServerSchema {
-	private:
-		static Json::Value getDefaultValueForDefaultNodeName(const ConfigKit::Store &store) {
-			return getHostName();
-		}
-
-	public:
-		Schema()
-			: ServerKit::BaseServerSchema(false)
-		{
-			using namespace ConfigKit;
-
-			add("ust_router_username", STRING_TYPE, OPTIONAL);
-			add("ust_router_password", STRING_TYPE, OPTIONAL);
-			add("ust_router_dump_dir", STRING_TYPE, OPTIONAL, "/tmp");
-			addWithDynamicDefault(
-				"ust_router_default_node_name",
-				STRING_TYPE, OPTIONAL | CACHE_DEFAULT_VALUE,
-				getDefaultValueForDefaultNodeName);
-			add("ust_router_dev_mode", BOOL_TYPE, OPTIONAL, false);
-			add("union_station_gateway_address", STRING_TYPE, OPTIONAL | READ_ONLY, DEFAULT_UNION_STATION_GATEWAY_ADDRESS);
-			add("union_station_gateway_port", UINT_TYPE, OPTIONAL | READ_ONLY, DEFAULT_UNION_STATION_GATEWAY_PORT);
-			add("union_station_gateway_cert", STRING_TYPE, OPTIONAL | READ_ONLY);
-			add("union_station_proxy_address", STRING_TYPE, OPTIONAL | READ_ONLY);
-			add("analytics_sink_flush_timer_interval", UINT_TYPE, OPTIONAL, 5);
-			add("analytics_sink_flush_interval", UINT_TYPE, OPTIONAL, 0);
-
-			finalize();
-		}
-	};
-
 	Controller(ServerKit::Context *context, const Schema &schema,
 		const Json::Value &initialConfig)
 		: ServerKit::BaseServer<Controller, Client>(context, schema, initialConfig),
+		  configRlz(config),
 		  remoteSender(
 		      config["union_station_gateway_address"].asString(),
 		      config["union_station_gateway_port"].asUInt(),
 		      config["union_station_gateway_cert"].asString(),
 		      config["union_station_proxy_address"].asString()),
 		  gcTimer(getLoop()),
-		  flushTimer(getLoop()),
-		  devMode(false),
-		  sinkFlushInterval(0)
+		  flushTimer(getLoop())
 	{
 		gcTimer.set<Controller, &Controller::garbageCollect>(this);
 		gcTimer.start(GARBAGE_COLLECTION_TIMEOUT, GARBAGE_COLLECTION_TIMEOUT);
 
 		flushTimer.set<Controller, &Controller::flushSomeSinks>(this);
-
-		applyConfigUpdates();
 	}
 
 	virtual StaticString getServerName() const {
@@ -1212,12 +1218,32 @@ public:
 		return pos - buf;
 	}
 
+	bool prepareConfigChange(const Json::Value &updates,
+		vector<ConfigKit::Error> &errors, ConfigChangeRequest &req)
+	{
+		if (ParentClass::prepareConfigChange(updates, errors, req.forParent)) {
+			req.configRlz.reset(new ConfigRealization(*req.forParent.config));
+		}
+		return errors.empty();
+	}
+
+	void commitConfigChange(ConfigChangeRequest &req)
+		BOOST_NOEXCEPT_OR_NOTHROW
+	{
+		ParentClass::commitConfigChange(req.forParent);
+		configRlz.swap(*req.configRlz);
+
+		flushTimer.stop();
+		flushTimer.start(configRlz.sinkFlushTimerInterval,
+			configRlz.sinkFlushTimerInterval);
+	}
+
 	virtual Json::Value inspectStateAsJson() const {
 		Json::Value doc = ParentClass::inspectStateAsJson();
-		doc["dev_mode"] = devMode;
+		doc["dev_mode"] = configRlz.devMode;
 		doc["log_sink_cache"] = inspectLogSinkCacheStateAsJson();
 		doc["transactions"] = inspectTransactionsStateAsJson();
-		if (devMode) {
+		if (configRlz.devMode) {
 			doc["dump_dir"] = config["ust_router_dump_dir"];
 		} else {
 			doc["remote_sender"] = remoteSender.inspectStateAsJson();

data/src/agent/UstRouter/RemoteSender.h

@@ -41,7 +41,7 @@
 #include <jsoncpp/json.h>
 #include <modp_b64.h>
 
-#include <Logging.h>
+#include <LoggingKit/LoggingKit.h>
 #include <StaticString.h>
 #include <Utils.h>
 #include <Utils/BlockingQueue.h>

data/src/agent/UstRouter/RemoteSink.h

@@ -30,7 +30,7 @@
 #include <cstring>
 #include <ctime>
 #include <ev++.h>
-#include <Logging.h>
+#include <LoggingKit/LoggingKit.h>
 #include <UstRouter/LogSink.h>
 #include <UstRouter/RemoteSender.h>
 

data/src/agent/Watchdog/ApiServer.h

@@ -26,8 +26,8 @@
 #ifndef _PASSENGER_WATCHDOG_AGENT_API_SERVER_H_
 #define _PASSENGER_WATCHDOG_AGENT_API_SERVER_H_
 
-#include <sstream>
 #include <string>
+#include <exception>
 #include <cstring>
 #include <jsoncpp/json.h>
 #include <modp_b64.h>
@@ -37,7 +37,7 @@
 #include <DataStructures/LString.h>
 #include <Exceptions.h>
 #include <StaticString.h>
-#include <Logging.h>
+#include <LoggingKit/LoggingKit.h>
 #include <Constants.h>
 #include <Utils/StrIntUtils.h>
 #include <Utils/MessageIO.h>
@@ -109,19 +109,8 @@ private:
 			}
 
 			HeaderTable headers;
-			Json::Value doc;
-			string logFile = getLogFile();
-			string fileDescriptorLogFile = getFileDescriptorLogFile();
-
+			Json::Value doc = LoggingKit::context->getConfig().inspect();
 			headers.insert(req->pool, "Content-Type", "application/json");
-			doc["log_level"] = getLogLevel();
-			if (!logFile.empty()) {
-				doc["log_file"] = logFile;
-			}
-			if (!fileDescriptorLogFile.empty()) {
-				doc["file_descriptor_log_file"] = fileDescriptorLogFile;
-			}
-
 			writeSimpleResponse(client, 200, &headers, doc.toStyledString());
 			if (!req->ended()) {
 				endRequest(&client, &req);
@@ -140,46 +129,43 @@ private:
 
 	void processConfigBody(Client *client, Request *req) {
 		HeaderTable headers;
-		Json::Value &json = req->jsonBody;
+		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");
 
-		if (json.isMember("log_level")) {
-			setLogLevel(json["log_level"].asInt());
-		}
-		if (json.isMember("log_file")) {
-			string logFile = json["log_file"].asString();
-			try {
-				logFile = absolutizePath(logFile);
-			} catch (const SystemException &e) {
-				unsigned int bufsize = 1024;
-				char *message = (char *) psg_pnalloc(req->pool, bufsize);
-				snprintf(message, bufsize, "{ \"status\": \"error\", "
-					"\"message\": \"Cannot absolutize log file filename: %s\" }",
-					e.what());
-				writeSimpleResponse(client, 500, &headers, message);
-				if (!req->ended()) {
-					endRequest(&client, &req);
-				}
-				return;
+		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);
 			}
-
-			int e;
-			if (!setLogFile(logFile, &e)) {
-				unsigned int bufsize = 1024;
-				char *message = (char *) psg_pnalloc(req->pool, bufsize);
-				snprintf(message, bufsize, "{ \"status\": \"error\", "
-					"\"message\": \"Cannot open log file: %s (errno=%d)\" }",
-					strerror(e), e);
-				writeSimpleResponse(client, 500, &headers, message);
-				if (!req->ended()) {
-					endRequest(&client, &req);
-				}
-				return;
+			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\" }",
+				ConfigKit::toString(errors).c_str());
+			writeSimpleResponse(client, 500, &headers, message);
+			if (!req->ended()) {
+				endRequest(&client, &req);
 			}
-			P_NOTICE("Log file opened.");
+			return;
 		}
 
+		LoggingKit::context->commitConfigChange(configReq);
 		writeSimpleResponse(client, 200, &headers, "{ \"status\": \"ok\" }");
 		if (!req->ended()) {
 			endRequest(&client, &req);
@@ -201,10 +187,14 @@ private:
 		if (req->method != HTTP_GET) {
 			apiServerRespondWith405(this, client, req);
 		} else if (authorizeFdPassingOperation(client, req)) {
+			ConfigKit::Store config = LoggingKit::context->getConfig();
 			HeaderTable headers;
 			headers.insert(req->pool, "Cache-Control", "no-cache, no-store, must-revalidate");
 			headers.insert(req->pool, "Content-Type", "text/plain");
-			headers.insert(req->pool, "Filename", getLogFile());
+			if (config["target"].isMember("path")) {
+				headers.insert(req->pool, "Filename",
+					psg_pstrdup(req->pool, config["target"]["path"].asString()));
+			}
 			req->wantKeepAlive = false;
 			writeSimpleResponse(client, 200, &headers, "");
 			if (req->ended()) {
@@ -213,9 +203,11 @@ private:
 
 			unsigned long long timeout = 1000000;
 			setBlocking(client->getFd());
-			writeFileDescriptorWithNegotiation(client->getFd(), STDERR_FILENO,
+			ScopeGuard guard(boost::bind(setNonBlocking, client->getFd()));
+			writeFileDescriptorWithNegotiation(client->getFd(),
+				LoggingKit::context->getConfigRealization()->targetFd,
 				&timeout);
-			setNonBlocking(client->getFd());
+			guard.runNow();
 
 			if (!req->ended()) {
 				endRequest(&client, &req);

data/src/agent/Watchdog/WatchdogMain.cpp

@@ -72,7 +72,7 @@
 #include <FileDescriptor.h>
 #include <RandomGenerator.h>
 #include <BackgroundEventLoop.h>
-#include <Logging.h>
+#include <LoggingKit/LoggingKit.h>
 #include <Exceptions.h>
 #include <StaticString.h>
 #include <Hooks.h>

data/src/apache2_module/Configuration.hpp

@@ -26,7 +26,7 @@
 #ifndef _PASSENGER_CONFIGURATION_HPP_
 #define _PASSENGER_CONFIGURATION_HPP_
 
-#include <Logging.h>
+#include <LoggingKit/LoggingKit.h>
 #include <Constants.h>
 #include <Utils.h>
 #include <Utils/VariantMap.h>

data/src/apache2_module/Hooks.cpp

@@ -61,7 +61,7 @@
 #include <Utils/SystemTime.h>
 #include <Utils/HttpConstants.h>
 #include <Utils/ReleaseableScopedPointer.h>
-#include <Logging.h>
+#include <LoggingKit/LoggingKit.h>
 #include <WatchdogLauncher.h>
 #include <Constants.h>
 
@@ -1239,20 +1239,33 @@ public:
 	{
 		passenger_postprocess_config(s);
 
-		Passenger::setLogLevel(serverConfig.logLevel);
+		Json::Value loggingConfig;
+		loggingConfig["level"] = LoggingKit::Level(serverConfig.logLevel);
+		loggingConfig["redirect_stderr"] = false;
 		if (serverConfig.logFile != NULL) {
-			int errcode;
-			if (!Passenger::setLogFileWithoutRedirectingStderr(serverConfig.logFile, &errcode)) {
-				fprintf(stderr,
-					"ERROR: cannot open log file %s: %s (errno=%d)\n",
-					serverConfig.logFile,
-					strerror(errcode),
-					errcode);
-			}
+			loggingConfig["target"] = serverConfig.logFile;
 		}
 		if (serverConfig.fileDescriptorLogFile != NULL) {
-			Passenger::setFileDescriptorLogFile(serverConfig.fileDescriptorLogFile);
+			loggingConfig["file_descriptor_log_target"] =
+				serverConfig.fileDescriptorLogFile;
+		}
+
+		vector<ConfigKit::Error> errors;
+		LoggingKit::ConfigChangeRequest req;
+		bool ok;
+		try {
+			ok = LoggingKit::context->prepareConfigChange(loggingConfig,
+				errors, req);
+		} catch (const std::exception &e) {
+			fprintf(stderr, "ERROR: unable to configure logging system: %s\n", e.what());
+		}
+		if (ok) {
+			LoggingKit::context->commitConfigChange(req);
+		} else {
+			fprintf(stderr, "ERROR: unable to configuring logging system: %s\n",
+				ConfigKit::toString(errors).c_str());
 		}
+
 		m_hasModRewrite = UNKNOWN;
 		m_hasModDir = UNKNOWN;
 		m_hasModAutoIndex = UNKNOWN;
@@ -1596,6 +1609,7 @@ init_module(apr_pool_t *pconf, apr_pool_t *plog, apr_pool_t *ptemp, server_rec *
 	 */
 	if (hooks == NULL) {
 		oxt::initialize();
+		LoggingKit::initialize();
 		SystemTime::initialize();
 	} else {
 		P_DEBUG("Restarting Phusion Passenger....");
@@ -1609,13 +1623,13 @@ init_module(apr_pool_t *pconf, apr_pool_t *plog, apr_pool_t *ptemp, server_rec *
 			apr_pool_cleanup_null);
 		return OK;
 
-	} catch (const thread_interrupted &e) {
+	} catch (const boost::thread_interrupted &e) {
 		P_TRACE(2, "A system call was interrupted during mod_passenger "
 			"initialization. Apache might be restarting or shutting "
 			"down. Backtrace:\n" << e.backtrace());
 		return DECLINED;
 
-	} catch (const thread_resource_error &e) {
+	} catch (const boost::thread_resource_error &e) {
 		struct rlimit lim;
 		string pthread_threads_max;
 		int ret;