passenger 5.0.9 → 5.0.10

data/ext/common/ApplicationPool2/Pool/{AnalyticsCollection.h → AnalyticsCollection.cpp}

@@ -22,23 +22,32 @@
  *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  *  THE SOFTWARE.
  */
+#include <ApplicationPool2/Pool.h>
 
-// This file is included inside the Pool class.
+/*************************************************************************
+ *
+ * Analytics collection functions for ApplicationPool2::Pool
+ *
+ *************************************************************************/
 
-private:
+namespace Passenger {
+namespace ApplicationPool2 {
 
-struct UnionStationLogEntry {
-	string groupName;
-	const char *category;
-	string key;
-	string data;
-};
+using namespace std;
+using namespace boost;
 
-SystemMetricsCollector systemMetricsCollector;
-SystemMetrics systemMetrics;
 
+void
+Pool::initializeAnalyticsCollection() {
+	interruptableThreads.create_thread(
+		boost::bind(collectAnalytics, shared_from_this()),
+		"Pool analytics collector",
+		POOL_HELPER_THREAD_STACK_SIZE
+	);
+}
 
-static void collectAnalytics(PoolPtr self) {
+void
+Pool::collectAnalytics(PoolPtr self) {
 	TRACE_POINT();
 	syscalls::usleep(3000000);
 	while (!this_thread::interruption_requested()) {
@@ -70,25 +79,27 @@ static void collectAnalytics(PoolPtr self) {
 	}
 }
 
-static void collectPids(const ProcessList &processes, vector<pid_t> &pids) {
+void
+Pool::collectPids(const ProcessList &processes, vector<pid_t> &pids) {
 	foreach (const ProcessPtr &process, processes) {
-		pids.push_back(process->pid);
+		pids.push_back(process->getPid());
 	}
 }
 
-static void updateProcessMetrics(const ProcessList &processes,
+void
+Pool::updateProcessMetrics(const ProcessList &processes,
 	const ProcessMetricMap &allMetrics,
 	vector<ProcessPtr> &processesToDetach)
 {
 	foreach (const ProcessPtr &process, processes) {
 		ProcessMetricMap::const_iterator metrics_it =
-			allMetrics.find(process->pid);
+			allMetrics.find(process->getPid());
 		if (metrics_it != allMetrics.end()) {
 			process->metrics = metrics_it->second;
 		// If the process is missing from 'allMetrics' then either 'ps'
 		// failed or the process really is gone. We double check by sending
 		// it a signal.
-		} else if (!process->dummy && !process->osProcessExists()) {
+		} else if (!process->isDummy() && !process->osProcessExists()) {
 			P_WARN("Process " << process->inspect() << " no longer exists! "
 				"Detaching it from the pool.");
 			processesToDetach.push_back(process);
@@ -96,7 +107,8 @@ static void updateProcessMetrics(const ProcessList &processes,
 	}
 }
 
-void prepareUnionStationProcessStateLogs(vector<UnionStationLogEntry> &logEntries,
+void
+Pool::prepareUnionStationProcessStateLogs(vector<UnionStationLogEntry> &logEntries,
 	const GroupPtr &group) const
 {
 	const UnionStation::CorePtr &unionStationCore = getUnionStationCore();
@@ -116,7 +128,8 @@ void prepareUnionStationProcessStateLogs(vector<UnionStationLogEntry> &logEntrie
 	}
 }
 
-void prepareUnionStationSystemMetricsLogs(vector<UnionStationLogEntry> &logEntries,
+void
+Pool::prepareUnionStationSystemMetricsLogs(vector<UnionStationLogEntry> &logEntries,
 	const GroupPtr &group) const
 {
 	const UnionStation::CorePtr &unionStationCore = getUnionStationCore();
@@ -135,7 +148,8 @@ void prepareUnionStationSystemMetricsLogs(vector<UnionStationLogEntry> &logEntri
 	}
 }
 
-void realCollectAnalytics() {
+void
+Pool::realCollectAnalytics() {
 	TRACE_POINT();
 	this_thread::disable_interruption di;
 	this_thread::disable_syscall_interruption dsi;
@@ -153,19 +167,14 @@ void realCollectAnalytics() {
 	{
 		UPDATE_TRACE_POINT();
 		LockGuard l(syncher);
-		SuperGroupMap::ConstIterator sg_it(superGroups);
-
-		while (*sg_it != NULL) {
-			const SuperGroupPtr &superGroup = sg_it.getValue();
-			SuperGroup::GroupList::const_iterator g_it, g_end = superGroup->groups.end();
-
-			for (g_it = superGroup->groups.begin(); g_it != g_end; g_it++) {
-				const GroupPtr &group = *g_it;
-				collectPids(group->enabledProcesses, pids);
-				collectPids(group->disablingProcesses, pids);
-				collectPids(group->disabledProcesses, pids);
-			}
-			sg_it.next();
+		GroupMap::ConstIterator g_it(groups);
+
+		while (*g_it != NULL) {
+			const GroupPtr &group = g_it.getValue();
+			collectPids(group->enabledProcesses, pids);
+			collectPids(group->disablingProcesses, pids);
+			collectPids(group->disabledProcesses, pids);
+			g_it.next();
 		}
 	}
 
@@ -174,6 +183,7 @@ void realCollectAnalytics() {
 	ProcessMetricMap processMetrics;
 	try {
 		UPDATE_TRACE_POINT();
+		P_DEBUG("Collecting process metrics");
 		processMetrics = ProcessMetricsCollector().collect(pids);
 	} catch (const ParseException &) {
 		P_WARN("Unable to collect process metrics: cannot parse 'ps' output.");
@@ -181,6 +191,7 @@ void realCollectAnalytics() {
 	}
 	try {
 		UPDATE_TRACE_POINT();
+		P_DEBUG("Collecting system metrics");
 		systemMetricsCollector.collect(systemMetrics);
 	} catch (const RuntimeException &e) {
 		P_WARN("Unable to collect system metrics: " << e.what());
@@ -193,23 +204,17 @@ void realCollectAnalytics() {
 		vector<ProcessPtr> processesToDetach;
 		boost::container::vector<Callback> actions;
 		ScopedLock l(syncher);
-		SuperGroupMap::ConstIterator sg_it(superGroups);
+		GroupMap::ConstIterator g_it(groups);
 
 		UPDATE_TRACE_POINT();
-		while (*sg_it != NULL) {
-			const SuperGroupPtr &superGroup = sg_it.getValue();
-			SuperGroup::GroupList::iterator g_it, g_end = superGroup->groups.end();
-
-			for (g_it = superGroup->groups.begin(); g_it != g_end; g_it++) {
-				const GroupPtr &group = *g_it;
-
-				updateProcessMetrics(group->enabledProcesses, processMetrics, processesToDetach);
-				updateProcessMetrics(group->disablingProcesses, processMetrics, processesToDetach);
-				updateProcessMetrics(group->disabledProcesses, processMetrics, processesToDetach);
-				prepareUnionStationProcessStateLogs(logEntries, group);
-				prepareUnionStationSystemMetricsLogs(logEntries, group);
-			}
-			sg_it.next();
+		while (*g_it != NULL) {
+			const GroupPtr &group = g_it.getValue();
+			updateProcessMetrics(group->enabledProcesses, processMetrics, processesToDetach);
+			updateProcessMetrics(group->disablingProcesses, processMetrics, processesToDetach);
+			updateProcessMetrics(group->disabledProcesses, processMetrics, processesToDetach);
+			prepareUnionStationProcessStateLogs(logEntries, group);
+			prepareUnionStationSystemMetricsLogs(logEntries, group);
+			g_it.next();
 		}
 
 		UPDATE_TRACE_POINT();
@@ -223,6 +228,7 @@ void realCollectAnalytics() {
 		UPDATE_TRACE_POINT();
 		if (!logEntries.empty()) {
 			const UnionStation::CorePtr &unionStationCore = getUnionStationCore();
+			P_DEBUG("Sending process and system metrics to Union Station");
 			while (!logEntries.empty()) {
 				UnionStationLogEntry &entry = logEntries.back();
 				UnionStation::TransactionPtr transaction =
@@ -244,12 +250,5 @@ void realCollectAnalytics() {
 }
 
 
-protected:
-
-void initializeAnalyticsCollection() {
-	interruptableThreads.create_thread(
-		boost::bind(collectAnalytics, shared_from_this()),
-		"Pool analytics collector",
-		POOL_HELPER_THREAD_STACK_SIZE
-	);
-}
+} // namespace ApplicationPool2
+} // namespace Passenger

data/ext/common/ApplicationPool2/Pool/{GarbageCollection.h → GarbageCollection.cpp}

@@ -22,21 +22,32 @@
  *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  *  THE SOFTWARE.
  */
+#include <ApplicationPool2/Pool.h>
 
-// This file is included inside the Pool class.
+/*************************************************************************
+ *
+ * Garbage collection functions for ApplicationPool2::Pool
+ *
+ *************************************************************************/
 
-private:
+namespace Passenger {
+namespace ApplicationPool2 {
 
-struct GarbageCollectorState {
-	unsigned long long now;
-	unsigned long long nextGcRunTime;
-	boost::container::vector<Callback> actions;
-};
+using namespace std;
+using namespace boost;
 
-boost::condition_variable garbageCollectionCond;
 
+void
+Pool::initializeGarbageCollection() {
+	interruptableThreads.create_thread(
+		boost::bind(garbageCollect, shared_from_this()),
+		"Pool garbage collector",
+		POOL_HELPER_THREAD_STACK_SIZE
+	);
+}
 
-static void garbageCollect(PoolPtr self) {
+void
+Pool::garbageCollect(PoolPtr self) {
 	TRACE_POINT();
 	{
 		ScopedLock lock(self->syncher);
@@ -59,13 +70,15 @@ static void garbageCollect(PoolPtr self) {
 	}
 }
 
-void maybeUpdateNextGcRuntime(GarbageCollectorState &state, unsigned long candidate) {
+void
+Pool::maybeUpdateNextGcRuntime(GarbageCollectorState &state, unsigned long candidate) {
 	if (state.nextGcRunTime == 0 || candidate < state.nextGcRunTime) {
 		state.nextGcRunTime = candidate;
 	}
 }
 
-void checkWhetherProcessCanBeGarbageCollected(GarbageCollectorState &state,
+void
+Pool::checkWhetherProcessCanBeGarbageCollected(GarbageCollectorState &state,
 	const GroupPtr &group, const ProcessPtr &process, ProcessList &output)
 {
 	assert(maxIdleTime > 0);
@@ -82,7 +95,8 @@ void checkWhetherProcessCanBeGarbageCollected(GarbageCollectorState &state,
 	}
 }
 
-void garbageCollectProcessesInGroup(GarbageCollectorState &state,
+void
+Pool::garbageCollectProcessesInGroup(GarbageCollectorState &state,
 	const GroupPtr &group)
 {
 	ProcessList &processes = group->enabledProcesses;
@@ -102,19 +116,20 @@ void garbageCollectProcessesInGroup(GarbageCollectorState &state,
 	{
 		ProcessPtr process = *p_it;
 		P_DEBUG("Garbage collect idle process: " << process->inspect() <<
-			", group=" << group->name);
+			", group=" << group->getName());
 		group->detach(process, state.actions);
 		p_it++;
 	}
 }
 
-void maybeCleanPreloader(GarbageCollectorState &state, const GroupPtr &group) {
+void
+Pool::maybeCleanPreloader(GarbageCollectorState &state, const GroupPtr &group) {
 	if (group->spawner->cleanable() && group->options.getMaxPreloaderIdleTime() != 0) {
 		unsigned long long spawnerGcTime =
 			group->spawner->lastUsed() +
 			group->options.getMaxPreloaderIdleTime() * 1000000;
 		if (state.now >= spawnerGcTime) {
-			P_DEBUG("Garbage collect idle spawner: group=" << group->name);
+			P_DEBUG("Garbage collect idle spawner: group=" << group->getName());
 			group->cleanupSpawner(state.actions);
 		} else {
 			maybeUpdateNextGcRuntime(state, spawnerGcTime);
@@ -123,10 +138,10 @@ void maybeCleanPreloader(GarbageCollectorState &state, const GroupPtr &group) {
 }
 
 unsigned long long
-realGarbageCollect() {
+Pool::realGarbageCollect() {
 	TRACE_POINT();
 	ScopedLock lock(syncher);
-	SuperGroupMap::ConstIterator sg_it(superGroups);
+	GroupMap::ConstIterator g_it(groups);
 	GarbageCollectorState state;
 	state.now = SystemTime::getUsec();
 	state.nextGcRunTime = 0;
@@ -134,30 +149,21 @@ realGarbageCollect() {
 	P_DEBUG("Garbage collection time...");
 	verifyInvariants();
 
-	// For all supergroups and groups...
-	while (*sg_it != NULL) {
-		const SuperGroupPtr superGroup = sg_it.getValue();
-		SuperGroup::GroupList &groups = superGroup->groups;
-		SuperGroup::GroupList::iterator g_it, g_end = groups.end();
-
-		superGroup->verifyInvariants();
+	// For all groups...
+	while (*g_it != NULL) {
+		const GroupPtr group = g_it.getValue();
 
-		for (g_it = groups.begin(); g_it != g_end; g_it++) {
-			GroupPtr group = *g_it;
-
-			if (maxIdleTime > 0) {
-				// ...detach processes that have been idle for more than maxIdleTime.
-				garbageCollectProcessesInGroup(state, group);
-			}
+		if (maxIdleTime > 0) {
+			// ...detach processes that have been idle for more than maxIdleTime.
+			garbageCollectProcessesInGroup(state, group);
+		}
 
-			group->verifyInvariants();
+		group->verifyInvariants();
 
-			// ...cleanup the spawner if it's been idle for more than preloaderIdleTime.
-			maybeCleanPreloader(state, group);
-		}
+		// ...cleanup the spawner if it's been idle for more than preloaderIdleTime.
+		maybeCleanPreloader(state, group);
 
-		superGroup->verifyInvariants();
-		sg_it.next();
+		g_it.next();
 	}
 
 	verifyInvariants();
@@ -184,17 +190,11 @@ realGarbageCollect() {
 	return sleepTime;
 }
 
-
-protected:
-
-void initializeGarbageCollection() {
-	interruptableThreads.create_thread(
-		boost::bind(garbageCollect, shared_from_this()),
-		"Pool garbage collector",
-		POOL_HELPER_THREAD_STACK_SIZE
-	);
-}
-
-void wakeupGarbageCollector() {
+void
+Pool::wakeupGarbageCollector() {
 	garbageCollectionCond.notify_all();
 }
+
+
+} // namespace ApplicationPool2
+} // namespace Passenger

data/ext/common/ApplicationPool2/Pool/GeneralUtils.cpp

@@ -0,0 +1,241 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2011-2015 Phusion
+ *
+ *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
+ *
+ *  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 <ApplicationPool2/Pool.h>
+
+/*************************************************************************
+ *
+ * General utility functions for ApplicationPool2::Pool
+ *
+ *************************************************************************/
+
+namespace Passenger {
+namespace ApplicationPool2 {
+
+using namespace std;
+using namespace boost;
+
+
+/****************************
+ *
+ * Private methods
+ *
+ ****************************/
+
+
+const char *
+Pool::maybeColorize(const InspectOptions &options, const char *color) {
+	if (options.colorize) {
+		return color;
+	} else {
+		return "";
+	}
+}
+
+const char *
+Pool::maybePluralize(unsigned int count, const char *singular, const char *plural) {
+	if (count == 1) {
+		return singular;
+	} else {
+		return plural;
+	}
+}
+
+void
+Pool::runAllActions(const boost::container::vector<Callback> &actions) {
+	boost::container::vector<Callback>::const_iterator it, end = actions.end();
+	for (it = actions.begin(); it != end; it++) {
+		(*it)();
+	}
+}
+
+void
+Pool::runAllActionsWithCopy(boost::container::vector<Callback> actions) {
+	runAllActions(actions);
+}
+
+bool
+Pool::runHookScripts(const char *name,
+	const boost::function<void (HookScriptOptions &)> &setup) const
+{
+	if (agentsOptions != NULL) {
+		string hookName = string("hook_") + name;
+		string spec = agentsOptions->get(hookName, false);
+		if (!spec.empty()) {
+			HookScriptOptions options;
+			options.agentsOptions = agentsOptions;
+			options.name = name;
+			options.spec = spec;
+			setup(options);
+			return Passenger::runHookScripts(options);
+		} else {
+			return true;
+		}
+	} else {
+		return true;
+	}
+}
+
+void
+Pool::verifyInvariants() const {
+	// !a || b: logical equivalent of a IMPLIES b.
+	#ifndef NDEBUG
+	if (!selfchecking) {
+		return;
+	}
+	assert(!( !getWaitlist.empty() ) || ( atFullCapacityUnlocked() ));
+	assert(!( !atFullCapacityUnlocked() ) || ( getWaitlist.empty() ));
+	#endif
+}
+
+void
+Pool::verifyExpensiveInvariants() const {
+	#ifndef NDEBUG
+	if (!selfchecking) {
+		return;
+	}
+	vector<GetWaiter>::const_iterator it, end = getWaitlist.end();
+	for (it = getWaitlist.begin(); it != end; it++) {
+		const GetWaiter &waiter = *it;
+		const GroupPtr *group;
+		assert(!groups.lookup(waiter.options.getAppGroupName(), &group));
+	}
+	#endif
+}
+
+void
+Pool::fullVerifyInvariants() const {
+	TRACE_POINT();
+	verifyInvariants();
+	UPDATE_TRACE_POINT();
+	verifyExpensiveInvariants();
+	UPDATE_TRACE_POINT();
+
+	GroupMap::ConstIterator g_it(groups);
+	while (*g_it != NULL) {
+		const GroupPtr &group = g_it.getValue();
+		group->verifyInvariants();
+		group->verifyExpensiveInvariants();
+		g_it.next();
+	}
+}
+
+/**
+ * Process all waiters on the getWaitlist. Call when capacity has become free.
+ * This function assigns sessions to them by calling get() on the corresponding
+ * Groups, or by creating more Groups, in so far the new capacity allows.
+ */
+void
+Pool::assignSessionsToGetWaiters(boost::container::vector<Callback> &postLockActions) {
+	bool done = false;
+	vector<GetWaiter>::iterator it, end = getWaitlist.end();
+	vector<GetWaiter> newWaitlist;
+
+	for (it = getWaitlist.begin(); it != end && !done; it++) {
+		GetWaiter &waiter = *it;
+
+		Group *group = findMatchingGroup(waiter.options);
+		if (group != NULL) {
+			SessionPtr session = group->get(waiter.options, waiter.callback,
+				postLockActions);
+			if (session != NULL) {
+				postLockActions.push_back(boost::bind(GetCallback::call,
+					waiter.callback, session, ExceptionPtr()));
+			}
+			/* else: the callback has now been put in
+			 *       the group's get wait list.
+			 */
+		} else if (!atFullCapacityUnlocked()) {
+			createGroupAndAsyncGetFromIt(waiter.options, waiter.callback,
+				postLockActions);
+		} else {
+			/* Still cannot satisfy this get request. Keep it on the get
+			 * wait list and try again later.
+			 */
+			newWaitlist.push_back(waiter);
+		}
+	}
+
+	std::swap(getWaitlist, newWaitlist);
+}
+
+template<typename Queue>
+void
+Pool::assignExceptionToGetWaiters(Queue &getWaitlist,
+	const ExceptionPtr &exception,
+	boost::container::vector<Callback> &postLockActions)
+{
+	while (!getWaitlist.empty()) {
+		postLockActions.push_back(boost::bind(GetCallback::call,
+			getWaitlist.front().callback, SessionPtr(),
+			exception));
+		getWaitlist.pop_front();
+	}
+}
+
+void
+Pool::syncGetCallback(const SessionPtr &session, const ExceptionPtr &e,
+	void *userData)
+{
+	Ticket *ticket = static_cast<Ticket *>(userData);
+	ScopedLock lock(ticket->syncher);
+	if (OXT_LIKELY(session != NULL)) {
+		ticket->session = session;
+	} else {
+		ticket->exception = e;
+	}
+	ticket->cond.notify_one();
+}
+
+
+/****************************
+ *
+ * Public methods
+ *
+ ****************************/
+
+
+Context *
+Pool::getContext() {
+	return &context;
+}
+
+const SpawningKit::ConfigPtr &
+Pool::getSpawningKitConfig() const {
+	return context.getSpawningKitConfig();
+}
+
+const UnionStation::CorePtr &
+Pool::getUnionStationCore() const {
+	return getSpawningKitConfig()->unionStationCore;
+}
+
+const RandomGeneratorPtr &
+Pool::getRandomGenerator() const {
+	return getSpawningKitConfig()->randomGenerator;
+}
+
+
+} // namespace ApplicationPool2
+} // namespace Passenger