passenger 5.1.10 → 5.1.11

data/src/apache2_module/Hooks.cpp

@@ -1257,6 +1257,7 @@ public:
 			ok = LoggingKit::context->prepareConfigChange(loggingConfig,
 				errors, req);
 		} catch (const std::exception &e) {
+			ok = false;
 			fprintf(stderr, "ERROR: unable to configure logging system: %s\n", e.what());
 		}
 		if (ok) {
@@ -1576,6 +1577,8 @@ destroy_hooks(void *arg) {
 		boost::this_thread::disable_interruption di;
 		boost::this_thread::disable_syscall_interruption dsi;
 		P_DEBUG("Shutting down Phusion Passenger...");
+		LoggingKit::shutdown();
+		oxt::shutdown();
 		delete hooks;
 		hooks = NULL;
 	} catch (const thread_interrupted &) {
@@ -1609,8 +1612,8 @@ 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();
+		LoggingKit::initialize();
 	} else {
 		P_DEBUG("Restarting Phusion Passenger....");
 		delete hooks;

data/src/cxx_supportlib/ConfigKit/Store.h

@@ -252,6 +252,16 @@ private:
 	}
 
 public:
+	struct PreviewOptions {
+		bool filterSecrets;
+		bool shouldApplyInspectFilters;
+
+		PreviewOptions()
+			: filterSecrets(true),
+			  shouldApplyInspectFilters()
+			{ }
+	};
+
 	Store()
 		: schema(NULL),
 		  entries(0, 0),
@@ -352,7 +362,7 @@ public:
 	 *    are not passed through inspect filters.
 	 */
 	Json::Value previewUpdate(const Json::Value &updates, vector<Error> &errors,
-		bool filterSecrets = true, bool shouldApplyInspectFilters = true) const
+		const PreviewOptions &options = PreviewOptions()) const
 	{
 		if (!updates.isNull() && !updates.isObject()) {
 			errors.push_back(Error("The JSON document must be an object"));
@@ -360,10 +370,23 @@ public:
 		}
 
 		Json::Value result(Json::objectValue);
+		Store storeWithPreviewData(*this);
+		StringKeyTable<Entry>::Iterator p_it(storeWithPreviewData.entries);
 		StringKeyTable<Entry>::ConstIterator it(entries);
 		vector<Error> tmpErrors;
 		Error error;
 
+		while (*p_it != NULL) {
+			const HashedStaticString &key = p_it.getKey();
+			Entry &entry = p_it.getValue();
+
+			if (isWritable(entry) && updates.isMember(key)) {
+				entry.userValue = updates[key];
+			}
+
+			p_it.next();
+		}
+
 		while (*it != NULL) {
 			const HashedStaticString &key = it.getKey();
 			const Entry &entry = it.getValue();
@@ -376,8 +399,9 @@ public:
 			} else {
 				subdoc["user_value"] = entry.userValue;
 			}
+
 			if (entry.schemaEntry->defaultValueGetter) {
-				subdoc["default_value"] = entry.getDefaultValue(*this);
+				subdoc["default_value"] = entry.getDefaultValue(storeWithPreviewData);
 			}
 
 			const Json::Value &effectiveValue =
@@ -400,11 +424,11 @@ public:
 			applyNormalizers(result);
 		}
 
-		if (shouldApplyInspectFilters) {
+		if (options.shouldApplyInspectFilters) {
 			applyInspectFilters(result);
 		}
 
-		if (filterSecrets) {
+		if (options.filterSecrets) {
 			doFilterSecrets(result);
 		}
 
@@ -423,7 +447,10 @@ public:
 	 * Any keys not in `updates` do not affect existing values stored in the store.
 	 */
 	bool update(const Json::Value &updates, vector<Error> &errors) {
-		Json::Value preview = previewUpdate(updates, errors, false, false);
+		PreviewOptions options;
+		options.filterSecrets = false;
+		options.shouldApplyInspectFilters = false;
+		Json::Value preview = previewUpdate(updates, errors, options);
 		if (errors.empty()) {
 			StringKeyTable<Entry>::Iterator it(entries);
 			while (*it != NULL) {

data/src/cxx_supportlib/Constants.h

@@ -71,7 +71,6 @@
 #define DEFAULT_STICKY_SESSIONS_COOKIE_NAME "_passenger_route"
 #define DEFAULT_UNION_STATION_GATEWAY_ADDRESS "gateway.unionstationapp.com"
 #define DEFAULT_UNION_STATION_GATEWAY_PORT 443
-#define DEFAULT_UST_ROUTER_LISTEN_ADDRESS "tcp://127.0.0.1:9344"
 #define DEFAULT_WEB_APP_USER "nobody"
 #define ENTERPRISE_URL "https://www.phusionpassenger.com/enterprise"
 #define FEEDBACK_FD 3
@@ -83,7 +82,7 @@
 #define PASSENGER_API_VERSION_MAJOR 0
 #define PASSENGER_API_VERSION_MINOR 3
 #define PASSENGER_DEFAULT_USER "nobody"
-#define PASSENGER_VERSION "5.1.10"
+#define PASSENGER_VERSION "5.1.11"
 #define POOL_HELPER_THREAD_STACK_SIZE 262144
 #define PROCESS_SHUTDOWN_TIMEOUT 60
 #define PROCESS_SHUTDOWN_TIMEOUT_DISPLAY "1 minute"

data/src/cxx_supportlib/Crypto.cpp

@@ -294,7 +294,7 @@ CFDataRef Crypto::genIV(size_t ivSize) {
 
 bool Crypto::getKeyBytes(SecKeyRef cryptokey, void **target, size_t &len) {
 	const CSSM_KEY *cssmKey;
-	CSSM_WRAP_KEY wrappedKey = {{0}};
+	CSSM_WRAP_KEY wrappedKey;
 
 	CSSM_CSP_HANDLE cspHandle = 0;
 	CSSM_CC_HANDLE ccHandle = 0;
@@ -322,6 +322,7 @@ bool Crypto::getKeyBytes(SecKeyRef cryptokey, void **target, size_t &len) {
 											&ccHandle);
 	if (error != CSSM_OK) { cssmPerror("CSSM_CSP_CreateSymmetricContext",error); }
 
+	memset(&wrappedKey, 0, sizeof(wrappedKey));
 	error = CSSM_WrapKey(ccHandle,
 				 creds,
 				 cssmKey,

data/src/cxx_supportlib/Hooks.h

@@ -33,16 +33,15 @@
 #include <boost/foreach.hpp>
 #include <oxt/backtrace.hpp>
 
-#include <sys/types.h>
-#include <sys/wait.h>
 #include <cstdio>
 #include <cerrno>
 #include <cstring>
 #include <cctype>
 #include <stdlib.h>
-#include <unistd.h>
 
 #include <LoggingKit/LoggingKit.h>
+#include <ProcessManagement/Spawn.h>
+#include <ProcessManagement/Utils.h>
 #include <Utils.h>
 #include <Utils/StrIntUtils.h>
 #include <Utils/VariantMap.h>
@@ -126,44 +125,24 @@ runSingleHookScript(HookScriptOptions &options, const string &command,
 	const vector< pair<string, string> > &envvars)
 {
 	TRACE_POINT_WITH_DATA(command.c_str());
-	pid_t pid;
-	int e, status;
+	const char *commandArray[] = {
+		command.c_str(),
+		NULL
+	};
+	SubprocessInfo info;
 
 	P_INFO("Running " << options.name << " hook script: " << command);
-
-	pid = fork();
-	if (pid == 0) {
-		resetSignalHandlersAndMask();
-		disableMallocDebugging();
-		closeAllFileDescriptors(2);
-		setEnvVarsFromVector(envvars);
-
-		execlp(command.c_str(), command.c_str(), (const char * const) 0);
-		e = errno;
-		fprintf(stderr, "*** ERROR: Cannot execute %s hook script %s: %s (errno=%d)\n",
-			options.name.c_str(), command.c_str(), strerror(e), e);
-		fflush(stderr);
-		_exit(1);
-		return true; // Never reached.
-
-	} else if (pid == -1) {
-		e = errno;
-		P_ERROR("Cannot fork a process for hook script " << command <<
-			": " << strerror(e) << " (errno=" << e << ")");
-		return false;
-
-	} else if (waitpid(pid, &status, 0) == -1) {
-		e = errno;
-		P_ERROR("Unable to wait for hook script " << command <<
-			" (PID " << pid << "): " << strerror(e) << " (errno=" <<
-			e << ")");
+	try {
+		runCommand(commandArray, info, true, true, boost::bind(setEnvVarsFromVector, envvars));
+	} catch (const SystemException &e) {
+		P_ERROR("Error running hook script " << command << ": " << e.what());
 		return false;
-
-	} else {
-		P_INFO("Hook script " << command << " (PID " << pid <<
-			") exited with status " << WEXITSTATUS(status));
-		return WEXITSTATUS(status) == 0;
 	}
+	if (info.status != 0 && info.status != -2) {
+		P_INFO("Hook script " << command << " (PID " << info.pid <<
+			") exited with status " << WEXITSTATUS(info.status));
+	}
+	return info.status == 0 || info.status == -2;
 }
 
 inline bool

data/src/cxx_supportlib/LoggingKit/Context.h

@@ -26,12 +26,16 @@
 #ifndef _PASSENGER_LOGGING_KIT_CONTEXT_H_
 #define _PASSENGER_LOGGING_KIT_CONTEXT_H_
 
+#include <queue>
+
 #include <oxt/macros.hpp>
+#include <oxt/thread.hpp>
 #include <boost/thread.hpp>
 #include <boost/atomic.hpp>
 #include <ConfigKit/ConfigKit.h>
 #include <LoggingKit/Forward.h>
 #include <LoggingKit/Config.h>
+#include <Utils/SystemTime.h>
 
 namespace Passenger {
 namespace LoggingKit {
@@ -68,8 +72,15 @@ private:
 	ConfigKit::Store config;
 	boost::atomic<ConfigRealization *> configRlz;
 
+	mutable boost::mutex gcSyncher;
+	oxt::thread *gcThread;
+	boost::condition_variable gcShuttingDownCond, gcHasShutDownCond;
+	queue< pair<ConfigRealization *, MonotonicTimeUsec> > oldConfigs;
+	bool shuttingDown;
+
 public:
 	Context(const Json::Value &initialConfig = Json::Value());
+	~Context();
 	ConfigKit::Store getConfig() const;
 
 	bool prepareConfigChange(const Json::Value &updates,
@@ -82,6 +93,17 @@ public:
 	const ConfigRealization *getConfigRealization() const {
 		return configRlz.load(boost::memory_order_acquire);
 	}
+
+	void pushOldConfigAndCreateGcThread(ConfigRealization *oldConfigRlz, MonotonicTimeUsec monotonicNow);
+	void gcThreadMain();
+
+private:
+	pair<ConfigRealization*,MonotonicTimeUsec> peekOldConfig();
+	void popOldConfig(ConfigRealization *oldConfig);
+	bool oldConfigsExist();
+	void createGcThread();
+	void killGcThread();
+	void gcLockless(bool wait, boost::unique_lock<boost::mutex> &lock);
 };
 
 

data/src/cxx_supportlib/LoggingKit/Forward.h

@@ -75,6 +75,7 @@ extern Context *context;
 
 
 void initialize(const Json::Value &initialConfig = Json::Value());
+void shutdown();
 
 const char *_strdupFastStringStream(const FastStringStream<> &stream);
 bool _passesLogLevel(const Context *context, Level level, const ConfigRealization **outputConfigRlz);

data/src/cxx_supportlib/LoggingKit/Implementation.cpp

@@ -32,8 +32,10 @@
 #include <cstring>
 #include <cerrno>
 #include <cassert>
+#include <queue>
 #include <sys/time.h>
 #include <fcntl.h>
+#include <utility>
 #include <unistd.h>
 #include <time.h>
 #include <pthread.h>
@@ -53,6 +55,7 @@
 #include <ConfigKit/ConfigKit.h>
 #include <Utils.h>
 #include <Utils/StrIntUtils.h>
+#include <Utils/SystemTime.h>
 
 namespace Passenger {
 namespace LoggingKit {
@@ -71,6 +74,11 @@ initialize(const Json::Value &initialConfig) {
 	context = new Context(initialConfig);
 }
 
+void
+shutdown() {
+	delete context;
+	context = NULL;
+}
 
 Level getLevel() {
 	if (OXT_LIKELY(context != NULL)) {
@@ -397,13 +405,32 @@ normalizeConfig(const Json::Value &effectiveValues) {
 
 
 Context::Context(const Json::Value &initialConfig)
-	: config(schema, initialConfig)
+	: config(schema, initialConfig),
+	  gcThread(NULL),
+	  shuttingDown(false)
 {
 	configRlz.store(new ConfigRealization(config));
 	configRlz.load()->apply(config, NULL);
 	configRlz.load()->finalize();
 }
 
+Context::~Context() {
+	boost::unique_lock<boost::mutex> l(gcSyncher);
+
+	// If a gc thread exists, tell it to shut down and
+	// wait until it has done so.
+	shuttingDown = true;
+	gcShuttingDownCond.notify_one();
+	while (gcThread != NULL) {
+		gcHasShutDownCond.wait(l);
+	}
+
+	killGcThread();
+	gcLockless(false, l);
+
+	delete configRlz.load();
+}
+
 ConfigKit::Store
 Context::getConfig() const {
 	boost::lock_guard<boost::mutex> l(syncher);
@@ -442,6 +469,82 @@ Context::commitConfigChange(LoggingKit::ConfigChangeRequest &req) BOOST_NOEXCEPT
 	newConfigRlz->finalize();
 }
 
+pair<ConfigRealization*,MonotonicTimeUsec>
+Context::peekOldConfig() {
+	return oldConfigs.front();
+}
+
+void
+Context::popOldConfig(ConfigRealization *oldConfig) {
+	delete oldConfig;
+	oldConfigs.pop();
+}
+
+void
+Context::createGcThread() {
+	if (gcThread == NULL) {
+		try {
+			gcThread = new oxt::thread(boost::bind(&Context::gcThreadMain, this),
+				"LoggingKit config garbage collector thread",
+				128 * 1024);
+		} catch (const std::exception &e) {
+			P_ERROR("Error spawning background thread to garbage collect"
+				" old LoggingKit configuration: " << e.what());
+		}
+	}
+}
+
+void
+Context::pushOldConfigAndCreateGcThread(ConfigRealization *oldConfigRlz, MonotonicTimeUsec monotonicNow) {
+	// Garbage collect old config realization in 5 minutes.
+	// There is no way to cheaply find out whether oldConfigRlz
+	// is still being used (we don't want to resort to more atomic
+	// operations, or conservative garbage collection) but
+	// waiting 5 minutes should be good enough.
+	MonotonicTimeUsec gcTime = monotonicNow + 5llu * 60llu * 1000000llu;
+	boost::unique_lock<boost::mutex> l(gcSyncher);
+	oldConfigs.push(make_pair(oldConfigRlz, gcTime));
+	createGcThread();
+}
+
+bool
+Context::oldConfigsExist() {
+	return !oldConfigs.empty();
+}
+
+void
+Context::gcThreadMain() {
+	boost::unique_lock<boost::mutex> l(gcSyncher);
+	gcLockless(true, l);
+}
+
+void
+Context::gcLockless(bool wait, boost::unique_lock<boost::mutex> &lock) {
+	while (!shuttingDown && oldConfigsExist()) {
+		pair<ConfigRealization *, MonotonicTimeUsec> p = peekOldConfig();
+		for (MonotonicTimeUsec now = SystemTime::getMonotonicUsecWithGranularity<SystemTime::GRAN_1SEC>();
+			 !shuttingDown && wait && now < p.second;
+			 now = SystemTime::getMonotonicUsecWithGranularity<SystemTime::GRAN_1SEC>())
+		{
+			// Wait until it's time to GC this config object,
+			// or until the destructor tells us that we're shutting down.
+			gcShuttingDownCond.timed_wait(lock, boost::posix_time::microseconds(p.second - now));
+		}
+		if (!shuttingDown) {
+			popOldConfig(p.first);
+		}
+	}
+	killGcThread();
+}
+
+void
+Context::killGcThread() {
+	if (gcThread != NULL) {
+		delete gcThread;
+		gcThread = NULL;
+	}
+	gcHasShutDownCond.notify_one();
+}
 
 Json::Value
 Schema::createStderrTarget() {
@@ -636,14 +739,6 @@ ConfigRealization::~ConfigRealization() {
 	}
 }
 
-static void
-garbageCollectConfigRealization(ConfigRealization *configRlz) {
-	boost::this_thread::disable_interruption di;
-	boost::this_thread::disable_syscall_interruption dsi;
-	syscalls::sleep(30);
-	delete configRlz;
-}
-
 void
 ConfigRealization::apply(const ConfigKit::Store &config, ConfigRealization *oldConfigRlz)
 	BOOST_NOEXCEPT_OR_NOTHROW
@@ -658,19 +753,8 @@ ConfigRealization::apply(const ConfigKit::Store &config, ConfigRealization *oldC
 	}
 
 	if (oldConfigRlz != NULL) {
-		// Garbage collect old config realization in 30 seconds.
-		// There is no way to cheaply find out whether oldConfigRlz
-		// is still being used (we don't want to resort to more atomic
-		// operations, or conservative garbage collection) but
-		// waiting 30 seconds should be good enough.
-		try {
-			oxt::thread(boost::bind(garbageCollectConfigRealization, oldConfigRlz),
-				"LoggingKit config garbage collector " + toString(oldConfigRlz),
-				128 * 1024);
-		} catch (const std::exception &e) {
-			P_ERROR("Error spawning background thread to garbage collect"
-				" old LoggingKit configuration: " << e.what());
-		}
+		MonotonicTimeUsec monotonicNow = SystemTime::getMonotonicUsecWithGranularity<SystemTime::GRAN_1SEC>();
+		context->pushOldConfigAndCreateGcThread(oldConfigRlz, monotonicNow);
 	}
 }