passenger 3.0.21 → 3.9.1.beta

data/ext/boost/utility/result_of.hpp

@@ -0,0 +1,103 @@
+// Boost result_of library
+
+//  Copyright Douglas Gregor 2004. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+// For more information, see http://www.boost.org/libs/utility
+#ifndef BOOST_RESULT_OF_HPP
+#define BOOST_RESULT_OF_HPP
+
+#include <boost/config.hpp>
+#include <boost/preprocessor/iteration/iterate.hpp> 
+#include <boost/preprocessor/punctuation/comma_if.hpp> 
+#include <boost/preprocessor/repetition/enum_params.hpp> 
+#include <boost/preprocessor/repetition/enum_binary_params.hpp> 
+#include <boost/preprocessor/repetition/enum_shifted_params.hpp> 
+#include <boost/preprocessor/facilities/intercept.hpp> 
+#include <boost/detail/workaround.hpp>
+#include <boost/mpl/has_xxx.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/type_traits/is_member_function_pointer.hpp>
+#include <boost/type_traits/remove_cv.hpp>
+#include <boost/utility/declval.hpp>
+
+#ifndef BOOST_RESULT_OF_NUM_ARGS
+#  define BOOST_RESULT_OF_NUM_ARGS 10
+#endif
+
+namespace boost {
+
+template<typename F> struct result_of;
+template<typename F> struct tr1_result_of; // a TR1-style implementation of result_of
+
+#if !defined(BOOST_NO_SFINAE) && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+namespace detail {
+
+BOOST_MPL_HAS_XXX_TRAIT_DEF(result_type)
+
+template<typename F, typename FArgs, bool HasResultType> struct tr1_result_of_impl;
+template<typename F> struct cpp0x_result_of_impl;
+
+template<typename F>
+struct result_of_void_impl
+{
+  typedef void type;
+};
+
+template<typename R>
+struct result_of_void_impl<R (*)(void)>
+{
+  typedef R type;
+};
+
+template<typename R>
+struct result_of_void_impl<R (&)(void)>
+{
+  typedef R type;
+};
+
+// Determine the return type of a function pointer or pointer to member.
+template<typename F, typename FArgs>
+struct result_of_pointer
+  : tr1_result_of_impl<typename remove_cv<F>::type, FArgs, false> { };
+
+template<typename F, typename FArgs>
+struct tr1_result_of_impl<F, FArgs, true>
+{
+  typedef typename F::result_type type;
+};
+
+template<typename FArgs>
+struct is_function_with_no_args : mpl::false_ {};
+
+template<typename F>
+struct is_function_with_no_args<F(void)> : mpl::true_ {};
+
+template<typename F, typename FArgs>
+struct result_of_nested_result : F::template result<FArgs>
+{};
+
+template<typename F, typename FArgs>
+struct tr1_result_of_impl<F, FArgs, false>
+  : mpl::if_<is_function_with_no_args<FArgs>,
+             result_of_void_impl<F>,
+             result_of_nested_result<F, FArgs> >::type
+{};
+
+} // end namespace detail
+
+#define BOOST_PP_ITERATION_PARAMS_1 (3,(0,BOOST_RESULT_OF_NUM_ARGS,<boost/utility/detail/result_of_iterate.hpp>))
+#include BOOST_PP_ITERATE()
+
+#else
+#  define BOOST_NO_RESULT_OF 1
+#endif
+
+}
+
+#endif // BOOST_RESULT_OF_HPP

data/ext/boost/utility/swap.hpp

@@ -0,0 +1,55 @@
+// Copyright (C) 2007, 2008 Steven Watanabe, Joseph Gauterin, Niels Dekker
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+// For more information, see http://www.boost.org
+
+
+#ifndef BOOST_UTILITY_SWAP_HPP
+#define BOOST_UTILITY_SWAP_HPP
+
+// Note: the implementation of this utility contains various workarounds:
+// - swap_impl is put outside the boost namespace, to avoid infinite
+// recursion (causing stack overflow) when swapping objects of a primitive
+// type.
+// - swap_impl has a using-directive, rather than a using-declaration,
+// because some compilers (including MSVC 7.1, Borland 5.9.3, and
+// Intel 8.1) don't do argument-dependent lookup when it has a
+// using-declaration instead.
+// - boost::swap has two template arguments, instead of one, to
+// avoid ambiguity when swapping objects of a Boost type that does
+// not have its own boost::swap overload.
+
+#include <algorithm> //for std::swap
+#include <cstddef> //for std::size_t
+
+namespace boost_swap_impl
+{
+  template<class T>
+  void swap_impl(T& left, T& right)
+  {
+    using namespace std;//use std::swap if argument dependent lookup fails
+    swap(left,right);
+  }
+
+  template<class T, std::size_t N>
+  void swap_impl(T (& left)[N], T (& right)[N])
+  {
+    for (std::size_t i = 0; i < N; ++i)
+    {
+      ::boost_swap_impl::swap_impl(left[i], right[i]);
+    }
+  }
+}
+
+namespace boost
+{
+  template<class T1, class T2>
+  void swap(T1& left, T2& right)
+  {
+    ::boost_swap_impl::swap_impl(left, right);
+  }
+}
+
+#endif

data/ext/common/AnsiColorConstants.h

@@ -0,0 +1,36 @@
+/*
+ *  Phusion Passenger - http://www.modrails.com/
+ *  Copyright (c) 2012 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.
+ */
+#ifndef _PASSENGER_ANSI_COLOR_CONSTANTS_H_
+
+#define ANSI_COLOR_RESET    "\e[0m"
+#define ANSI_COLOR_BOLD     "\e[1m"
+#define ANSI_COLOR_RED      "\e[31m"
+#define ANSI_COLOR_GREEN    "\e[32m"
+#define ANSI_COLOR_YELLOW   "\e[33m"
+#define ANSI_COLOR_WHITE    "\e[37m"
+#define ANSI_COLOR_BLACK_BG "\e[40m"
+#define ANSI_COLOR_BLUE_BG  "\e[44m"
+
+#endif /* _PASSENGER_ANSI_COLOR_CONSTANTS_H_ */

data/ext/common/ApplicationPool2/Common.h

@@ -0,0 +1,87 @@
+/*
+ *  Phusion Passenger - http://www.modrails.com/
+ *  Copyright (c) 2011, 2012 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.
+ */
+#ifndef _PASSENGER_APPLICATION_POOL2_COMMON_H_
+#define _PASSENGER_APPLICATION_POOL2_COMMON_H_
+
+#include <boost/thread.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/function.hpp>
+#include <oxt/tracable_exception.hpp>
+#include <ApplicationPool2/Options.h>
+#include <Utils/StringMap.h>
+
+namespace tut {
+	struct ApplicationPool2_PoolTest;
+}
+
+namespace Passenger {
+namespace ApplicationPool2 {
+
+using namespace std;
+using namespace boost;
+using namespace oxt;
+
+class Pool;
+class SuperGroup;
+class Group;
+class Process;
+class Session;
+
+typedef shared_ptr<Pool> PoolPtr;
+typedef shared_ptr<SuperGroup> SuperGroupPtr;
+typedef shared_ptr<Group> GroupPtr;
+typedef shared_ptr<Process> ProcessPtr;
+typedef shared_ptr<Session> SessionPtr;
+typedef shared_ptr<tracable_exception> ExceptionPtr;
+typedef StringMap<SuperGroupPtr> SuperGroupMap;
+typedef function<void (const SessionPtr &session, const ExceptionPtr &e)> GetCallback;
+typedef function<void ()> Callback;
+
+struct GetWaiter {
+	Options options;
+	GetCallback callback;
+	
+	GetWaiter(const Options &o, const GetCallback &cb)
+		: options(o),
+		  callback(cb)
+	{
+		options.persist(o);
+	}
+};
+
+struct Ticket {
+	boost::mutex syncher;
+	condition_variable cond;
+	SessionPtr session;
+	ExceptionPtr exception;
+};
+
+ExceptionPtr copyException(const tracable_exception &e);
+void rethrowException(const ExceptionPtr &e);
+
+} // namespace ApplicationPool2
+} // namespace Passenger
+
+#endif /* _PASSENGER_APPLICATION_POOL2_COMMON_H_ */

data/ext/common/ApplicationPool2/ComponentInfo.h

@@ -0,0 +1,53 @@
+/*
+ *  Phusion Passenger - http://www.modrails.com/
+ *  Copyright (c) 2011, 2012 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.
+ */
+#ifndef _PASSENGER_APPLICATION_POOL2_COMPONENT_INFO_H_
+#define _PASSENGER_APPLICATION_POOL2_COMPONENT_INFO_H_
+
+#include <string>
+
+namespace Passenger {
+namespace ApplicationPool2 {
+
+using namespace std;
+
+
+struct ComponentInfo {
+	string name;
+	bool   isDefault;
+	
+	/****************/
+	/****************/
+	
+	ComponentInfo() {
+		isDefault = false;
+		/******************/
+	}
+};
+
+
+} // namespace ApplicationPool2
+} // namespace Passenger
+
+#endif /* _PASSENGER_APPLICATION_POOL2_COMPONENT_INFO_H_ */

data/ext/common/ApplicationPool2/Group.h

@@ -0,0 +1,648 @@
+/*
+ *  Phusion Passenger - http://www.modrails.com/
+ *  Copyright (c) 2011, 2012 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.
+ */
+#ifndef _PASSENGER_APPLICATION_POOL2_GROUP_H_
+#define _PASSENGER_APPLICATION_POOL2_GROUP_H_
+
+#include <string>
+#include <map>
+#include <queue>
+#include <deque>
+#include <boost/thread.hpp>
+#include <boost/bind.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/make_shared.hpp>
+#include <oxt/macros.hpp>
+#include <oxt/thread.hpp>
+#include <cassert>
+#include <ApplicationPool2/Common.h>
+#include <ApplicationPool2/ComponentInfo.h>
+#include <ApplicationPool2/Spawner.h>
+#include <ApplicationPool2/Process.h>
+#include <ApplicationPool2/Options.h>
+#include <Utils/CachedFileStat.hpp>
+#include <Utils/FileChangeChecker.h>
+#include <Utils/SmallVector.h>
+
+namespace Passenger {
+namespace ApplicationPool2 {
+
+using namespace std;
+using namespace boost;
+using namespace oxt;
+
+
+/**
+ * Except for otherwise documented parts, this class is not thread-safe,
+ * so only access within ApplicationPool lock.
+ */
+class Group: public enable_shared_from_this<Group> {
+private:
+	friend class Pool;
+	friend class SuperGroup;
+	
+	struct GetAction {
+		GetCallback callback;
+		SessionPtr session;
+	};
+	
+	struct DisableWaiter {
+		ProcessPtr process;
+		Callback callback;
+		
+		DisableWaiter(const ProcessPtr &_process, const Callback &_callback)
+			: process(_process),
+			  callback(_callback)
+			{ }
+	};
+	
+	mutable boost::mutex backrefSyncher;
+	weak_ptr<SuperGroup> superGroup;
+	CachedFileStat cstat;
+	FileChangeChecker fileChangeChecker;
+	string restartFile;
+	string alwaysRestartFile;
+	
+	
+	static void _onSessionInitiateFailure(Session *session) {
+		const ProcessPtr &process = session->getProcess();
+		GroupPtr group = process->getGroup();
+		if (OXT_LIKELY(group != NULL)) {
+			group->onSessionInitiateFailure(process, session);
+		}
+	}
+
+	static void _onSessionClose(Session *session) {
+		const ProcessPtr &process = session->getProcess();
+		GroupPtr group = process->getGroup();
+		if (OXT_LIKELY(group != NULL)) {
+			group->onSessionClose(process, session);
+		}
+	}
+	
+	void createInterruptableThread(const function<void ()> &func, const string &name,
+		unsigned int stackSize);
+	static string generateSecret(const SuperGroupPtr &superGroup);
+	void onSessionInitiateFailure(const ProcessPtr &process, Session *session);
+	void onSessionClose(const ProcessPtr &process, Session *session);
+	void spawnThreadMain(GroupPtr self, SpawnerPtr spawner, Options options);
+	void spawnThreadRealMain(const SpawnerPtr &spawner, const Options &options);
+	void finalizeRestart(GroupPtr self, Options options, SpawnerFactoryPtr spawnerFactory,
+		vector<Callback> postLockActions);
+	
+	void verifyInvariants() const {
+		// !a || b: logical equivalent of a IMPLIES b.
+		
+		assert(count >= 0);
+		assert(0 <= disablingCount && disablingCount <= count);
+		assert(processes.empty() == (count == 0));
+		assert(processes.empty() == (pqueue.top() == NULL));
+		assert(disabledCount >= 0);
+		assert(disabledProcesses.empty() == (disabledCount == 0));
+		assert(!( count > 0 && disablingCount == count ) || ( spawning() ));
+		
+		// Verify getWaitlist invariants.
+		assert(!( !getWaitlist.empty() ) || ( processes.empty() || pqueue.top()->atFullCapacity() ));
+		assert(!( !processes.empty() && !pqueue.top()->atFullCapacity() ) || ( getWaitlist.empty() ));
+		assert(!( processes.empty() && !spawning() && !restarting() ) || ( getWaitlist.empty() ));
+		assert(!( !getWaitlist.empty() ) || ( !processes.empty() || spawning() || restarting() ));
+		
+		// Verify disableWaitlist invariants.
+		assert((int) disableWaitlist.size() >= disablingCount);
+
+		// Verify m_spawning and m_restarting.
+		assert(!( m_restarting ) || !m_spawning);
+	}
+	
+	void resetOptions(const Options &newOptions) {
+		options = newOptions;
+		options.persist(newOptions);
+		options.clearPerRequestFields();
+		options.groupSecret = secret;
+	}
+	
+	void mergeOptions(const Options &other) {
+		options.maxRequests      = other.maxRequests;
+		options.minProcesses     = other.minProcesses;
+		options.statThrottleRate = other.statThrottleRate;
+		options.maxPreloaderIdleTime = other.maxPreloaderIdleTime;
+	}
+	
+	void runAllActions(const vector<Callback> &actions) {
+		vector<Callback>::const_iterator it, end = actions.end();
+		for (it = actions.begin(); it != end; it++) {
+			(*it)();
+		}
+	}
+
+	static void cleanupSpawner(SpawnerPtr spawner) {
+		try {
+			spawner->cleanup();
+		} catch (const thread_interrupted &) {
+			// Return.
+		}
+	}
+	
+	SessionPtr newSession() {
+		assert(count > 0);
+		Process *process   = pqueue.top();
+		SessionPtr session = process->newSession();
+		session->onInitiateFailure = _onSessionInitiateFailure;
+		session->onClose   = _onSessionClose;
+		pqueue.pop();
+		process->pqHandle  = pqueue.push(process, process->utilization());
+		return session;
+	}
+	
+	template<typename Lock>
+	void assignSessionsToGetWaitersQuickly(Lock &lock) {
+		SmallVector<GetAction, 50> actions;
+		actions.reserve(getWaitlist.size());
+		while (!getWaitlist.empty() && pqueue.top() != NULL && !pqueue.top()->atFullCapacity()) {
+			GetAction action;
+			action.callback = getWaitlist.front().callback;
+			action.session  = newSession();
+			getWaitlist.pop();
+			actions.push_back(action);
+		}
+		
+		verifyInvariants();
+		lock.unlock();
+		SmallVector<GetAction, 50>::const_iterator it, end = actions.end();
+		for (it = actions.begin(); it != end; it++) {
+			it->callback(it->session, ExceptionPtr());
+		}
+	}
+	
+	void assignSessionsToGetWaiters(vector<Callback> &postLockActions) {
+		while (!getWaitlist.empty() && pqueue.top() != NULL && !pqueue.top()->atFullCapacity()) {
+			postLockActions.push_back(boost::bind(
+				getWaitlist.front().callback, newSession(),
+				ExceptionPtr()));
+			getWaitlist.pop();
+		}
+	}
+	
+	void assignExceptionToGetWaiters(const ExceptionPtr &exception,
+		vector<Callback> &postLockActions)
+	{
+		while (!getWaitlist.empty()) {
+			postLockActions.push_back(boost::bind(
+				getWaitlist.front().callback, SessionPtr(),
+				exception));
+			getWaitlist.pop();
+		}
+	}
+	
+	void removeFromDisableWaitlist(const ProcessPtr &p, vector<Callback> &postLockActions) {
+		deque<DisableWaiter>::const_iterator it, end = disableWaitlist.end();
+		deque<DisableWaiter> newList;
+		for (it = disableWaitlist.begin(); it != end; it++) {
+			const DisableWaiter &waiter = *it;
+			const ProcessPtr process = waiter.process;
+			if (process == p) {
+				postLockActions.push_back(waiter.callback);
+			} else {
+				newList.push_back(waiter);
+			}
+		}
+		disableWaitlist = newList;
+	}
+	
+public:
+	Options options;
+	/** This name uniquely identifies this Group within its Pool. It can also be used as the display name. */
+	const string name;
+	/** A secret token that may be known among all processes in this Group. Used for securing
+	 * intra-group process communication.
+	 */
+	const string secret;
+	ComponentInfo componentInfo;
+	
+	/**
+	 * 'processes' contains all enabled processes in this group.
+	 * 'disabledProcesses' contains all disabled processes in this group.
+	 * They do not intersect.
+	 *
+	 * 'pqueue' orders all enabled processes according to utilization() values, from small to large.
+	 * 'count' indicates the total number of enabled processes in this group.
+	 * 'disablingCount' indicates the number of processes in 'processes' with enabled == DISABLING.
+	 * 'disabledCount' indicates the number of disabled processes.
+	 *
+	 * Invariants:
+	 *    count >= 0
+	 *    0 <= disablingCount <= count
+	 *    processes.size() == count
+	 *    processes.empty() == (pqueue.top() == NULL)
+	 *    disabledProcesses.size() == disabledCount
+	 *    if pqueue.top().atFullCapacity():
+	 *       All enabled processes are at full capacity.
+	 *    if (count > 0) and (disablingCount == count):
+	 *       spawning()
+	 *    for all process in processes:
+	 *       process.enabled == Process::ENABLED || process.enabled == Process::DISABLING
+	 *    for all process in disabledProcesses:
+	 *       process.enabled == Process::DISABLED
+	 */
+	int count;
+	int disablingCount;
+	int disabledCount;
+	PriorityQueue<Process> pqueue;
+	ProcessList processes;
+	ProcessList disabledProcesses;
+	
+	/**
+	 * get() requests for this group that cannot be immediately satisfied are
+	 * put on this wait list, which must be processed as soon as the necessary
+	 * resources have become free.
+	 *
+	 * Invariant 1:
+	 *    if getWaitlist is non-empty:
+	 *       processes.empty() or (all enabled processes are at full capacity)
+	 * Equivalently:
+	 *    if !processes.empty() and (an enabled process is not at full capacity):
+	 *        getWaitlist is empty.
+	 *
+	 * Invariant 2:
+	 *    if processes.empty() && !spawning() && !restarting():
+	 *       getWaitlist is empty
+	 * Equivalently:
+	 *    if getWaitlist is non-empty:
+	 *       !processes.empty() || spawning() || restarting()
+	 */
+	queue<GetWaiter> getWaitlist;
+	/**
+	 * Invariant:
+	 *    disableWaitlist.size() >= disablingCount
+	 */
+	deque<DisableWaiter> disableWaitlist;
+	
+	SpawnerPtr spawner;
+	/**
+	 * Whether process(es) are being spawned right now.
+	 */
+	bool m_spawning;
+	/** Whether a restart is in progress. While restarting is in progress,
+	 * it is not possible to signal the desire to spawn new process. If spawning
+	 * was already in progress when the restart was initiated, then the spawning
+	 * will abort as soon as possible.
+	 *
+	 * Invariant:
+	 *    if m_restarting: !m_spawning
+	 */
+	bool m_restarting;
+	
+	Group(const SuperGroupPtr &superGroup, const Options &options, const ComponentInfo &info);
+	
+	SessionPtr get(const Options &newOptions, const GetCallback &callback) {
+		if (OXT_LIKELY(!restarting())) {
+			if (OXT_UNLIKELY(needsRestart(newOptions))) {
+				restart(newOptions);
+			} else {
+				mergeOptions(newOptions);
+			}
+			if (OXT_UNLIKELY(!newOptions.noop && shouldSpawn())) {
+				spawn();
+			}
+		}
+		
+		if (OXT_UNLIKELY(newOptions.noop)) {
+			ProcessPtr process = make_shared<Process>(SafeLibevPtr(),
+				0, string(), string(),
+				FileDescriptor(), FileDescriptor(),
+				SocketListPtr(), 0, 0);
+			process->setGroup(shared_from_this());
+			return make_shared<Session>(process, (Socket *) NULL);
+		}
+		
+		if (OXT_UNLIKELY(count == 0)) {
+			/* We don't have any processes yet, but it's on the way.
+			 * Call the callback after a process has been spawned
+			 * or has failed to spawn.
+			 */
+			assert(spawning() || restarting());
+			getWaitlist.push(GetWaiter(newOptions, callback));
+			P_DEBUG("No session checked out yet: group is spawning or restarting");
+			return SessionPtr();
+		} else {
+			Process *process = pqueue.top();
+			assert(process != NULL);
+			if (process->atFullCapacity()) {
+				/* Looks like all processes are at full capacity.
+				 * Wait until a new one has been spawned or until
+				 * resources have become free.
+				 */
+				getWaitlist.push(GetWaiter(newOptions, callback));
+				P_DEBUG("No session checked out yet: all processes are at full capacity");
+				return SessionPtr();
+			} else {
+				P_DEBUG("Session checked out from process " << process->inspect());
+				return newSession();
+			}
+		}
+	}
+	
+	// Thread-safe.
+	SuperGroupPtr getSuperGroup() const {
+		lock_guard<boost::mutex> lock(backrefSyncher);
+		return superGroup.lock();
+	}
+	
+	// Thread-safe.
+	void setSuperGroup(const SuperGroupPtr &superGroup) {
+		lock_guard<boost::mutex> lock(backrefSyncher);
+		this->superGroup = superGroup;
+	}
+	
+	// Thread-safe.
+	PoolPtr getPool() const;
+	
+	// Thread-safe.
+	bool detached() const {
+		return getSuperGroup() == NULL;
+	}
+	
+	/**
+	 * Attaches the given process to this Group and mark it as enabled. This
+	 * function doesn't touch getWaitlist so be sure to fix its invariants
+	 * afterwards if necessary.
+	 */
+	void attach(const ProcessPtr &process, vector<Callback> &postLockActions) {
+		assert(process->getGroup() == NULL);
+		process->setGroup(shared_from_this());
+		processes.push_back(process);
+		process->it = processes.last_iterator();
+		process->pqHandle = pqueue.push(process.get(), process->utilization());
+		process->enabled = Process::ENABLED;
+		count++;
+		
+		// Disable all processes in 'disableWaitlist' and call their callbacks
+		// outside the lock.
+		deque<DisableWaiter>::const_iterator it, end = disableWaitlist.end();
+		postLockActions.reserve(postLockActions.size() + disableWaitlist.size());
+		for (it = disableWaitlist.begin(); it != end; it++) {
+			const DisableWaiter &waiter = *it;
+			const ProcessPtr process = waiter.process;
+			// The same process can appear multiple times in disableWaitlist.
+			assert(process->enabled == Process::DISABLING
+				|| process->enabled == Process::DISABLED);
+			if (process->enabled == Process::DISABLING) {
+				process->enabled = Process::DISABLED;
+				processes.erase(process->it);
+				pqueue.erase(process->pqHandle);
+				disabledProcesses.push_back(process);
+				process->it = disabledProcesses.last_iterator();
+				count--;
+				disablingCount--;
+				disabledCount++;
+			}
+			postLockActions.push_back(waiter.callback);
+		}
+		disableWaitlist.clear();
+	}
+	
+	/**
+	 * Detaches the given process from this Group. This function doesn't touch
+	 * getWaitlist so be sure to fix its invariants afterwards if necessary.
+	 */
+	void detach(const ProcessPtr &process, vector<Callback> &postLockActions) {
+		assert(process->getGroup().get() == this);
+		if (process->enabled == Process::ENABLED || process->enabled == Process::DISABLING) {
+			assert(count > 0);
+			process->setGroup(GroupPtr());
+			processes.erase(process->it);
+			pqueue.erase(process->pqHandle);
+			count--;
+			if (process->enabled == Process::DISABLING) {
+				disablingCount--;
+				removeFromDisableWaitlist(process, postLockActions);
+			}
+		} else {
+			assert(!disabledProcesses.empty());
+			process->setGroup(GroupPtr());
+			disabledProcesses.erase(process->it);
+			disabledCount--;
+		}
+	}
+	
+	/**
+	 * Detaches all processes from this Group. This function doesn't touch
+	 * getWaitlist so be sure to fix its invariants afterwards if necessary.
+	 */
+	void detachAll(vector<Callback> &postLockActions) {
+		ProcessList::iterator it, end = processes.end();
+		for (it = processes.begin(); it != end; it++) {
+			(*it)->setGroup(GroupPtr());
+		}
+		
+		processes.clear();
+		disabledProcesses.clear();
+		pqueue.clear();
+		count = 0;
+		disablingCount = 0;
+		disabledCount = 0;
+		
+		postLockActions.reserve(disableWaitlist.size());
+		while (!disableWaitlist.empty()) {
+			const DisableWaiter &waiter = disableWaitlist.front();
+			assert(waiter.process->enabled == Process::DISABLING);
+			postLockActions.push_back(waiter.callback);
+			disableWaitlist.pop_front();
+		}
+	}
+	
+	/**
+	 * Marks the given process as enabled. This function doesn't touch getWaitlist
+	 * so be sure to fix its invariants afterwards if necessary.
+	 */
+	void enable(const ProcessPtr &process, vector<Callback> &postLockActions) {
+		assert(process->getGroup().get() == this);
+		if (process->enabled == Process::DISABLING) {
+			process->enabled = Process::ENABLED;
+			disablingCount--;
+			removeFromDisableWaitlist(process, postLockActions);
+		} else if (process->enabled == Process::DISABLED) {
+			disabledProcesses.erase(process->it);
+			processes.push_back(process);
+			process->it = processes.last_iterator();
+			process->pqHandle = pqueue.push(process.get(), process->utilization());
+			process->enabled = Process::ENABLED;
+			count++;
+			disabledCount--;
+		}
+	}
+	
+	/**
+	 * Marks the given process as disabled.
+	 */
+	bool disable(const ProcessPtr &process, const Callback &callback) {
+		assert(process->getGroup().get() == this);
+		if (process->enabled == Process::ENABLED) {
+			assert(count > 0);
+			if (count - disablingCount == 1) {
+				/* All processes are going to be disabled, so in order
+				 * to avoid blocking requests we first spawn a new process
+				 * and disable this process after the other one is done
+				 * spawning. We do this irregardless of resource limits
+				 * because we assume the administrator knows what he's
+				 * doing.
+				 */
+				process->enabled = Process::DISABLING;
+				disablingCount++;
+				disableWaitlist.push_back(DisableWaiter(process, callback));
+				spawn();
+				return false;
+			} else {
+				assert(count - disablingCount > 1);
+				processes.erase(process->it);
+				disabledProcesses.push_back(process);
+				pqueue.erase(process->pqHandle);
+				process->it = disabledProcesses.last_iterator();
+				process->enabled = Process::DISABLED;
+				return true;
+			}
+		} else if (process->enabled == Process::DISABLING) {
+			disableWaitlist.push_back(DisableWaiter(process, callback));
+			return false;
+		} else {
+			return true;
+		}
+	}
+
+	void asyncCleanupSpawner() {
+		createInterruptableThread(
+			boost::bind(cleanupSpawner, spawner),
+			"Group spawner cleanup: " + name,
+			POOL_HELPER_THREAD_STACK_SIZE);
+	}
+
+	unsigned int utilization() const {
+		int result = count;
+		if (spawning()) {
+			result++;
+		}
+		return result;
+	}
+	
+	bool garbageCollectable(unsigned long long now = 0) const {
+		/* if (now == 0) {
+			now = SystemTime::getUsec();
+		}
+		return utilization() == 0
+			&& getWaitlist.empty()
+			&& disabledProcesses.empty()
+			&& options.getMaxPreloaderIdleTime() != 0
+			&& now - spawner->lastUsed() >
+				(unsigned long long) options.getMaxPreloaderIdleTime() * 1000000; */
+		return false;
+	}
+	
+	/** Whether a new process should be spawned for this group in case
+	 * another get action is to be performed.
+	 */
+	bool shouldSpawn() const;
+	
+	/** Start spawning a new process in the background, in case this
+	 * isn't already happening and the group isn't being restarted.
+	 * Will ensure that at least options.minProcesses processes are spawned.
+	 */
+	void spawn() {
+		if (!spawning() && !restarting()) {
+			P_DEBUG("Requested spawning of new process for group " << name);
+			createInterruptableThread(
+				boost::bind(&Group::spawnThreadMain,
+					this, shared_from_this(), spawner,
+					options.copyAndPersist().clearPerRequestFields()),
+				"Group process spawner: " + name,
+				POOL_HELPER_THREAD_STACK_SIZE);
+			m_spawning = true;
+		}
+	}
+	
+	bool needsRestart(const Options &options) {
+		if (m_restarting) {
+			return false;
+		} else {
+			struct stat buf;
+			return cstat.stat(alwaysRestartFile, &buf, options.statThrottleRate) == 0 ||
+			       fileChangeChecker.changed(restartFile, options.statThrottleRate);
+		}
+	}
+	
+	void restart(const Options &options);
+	
+	bool spawning() const {
+		return m_spawning;
+	}
+
+	bool restarting() const {
+		return m_restarting;
+	}
+
+	template<typename Stream>
+	void inspectXml(Stream &stream, bool includeSecrets = true) const {
+		ProcessList::const_iterator it;
+
+		stream << "<name>" << escapeForXml(name) << "</name>";
+		stream << "<component_name>" << escapeForXml(componentInfo.name) << "</component_name>";
+		stream << "<app_root>" << escapeForXml(options.appRoot) << "</app_root>";
+		stream << "<app_type>" << escapeForXml(options.appType) << "</app_type>";
+		stream << "<environment>" << escapeForXml(options.environment) << "</environment>";
+		stream << "<process_count>" << (count + disabledCount) << "</process_count>";
+		stream << "<utilization>" << utilization() << "</utilization>";
+		stream << "<get_wait_list_size>" << getWaitlist.size() << "</get_wait_list_size>";
+		stream << "<disable_wait_list_size>" << disableWaitlist.size() << "</disable_wait_list_size>";
+		if (spawning()) {
+			stream << "<spawning/>";
+		}
+		if (restarting()) {
+			stream << "<restarting/>";
+		}
+		if (includeSecrets) {
+			stream << "<secret>" << escapeForXml(secret) << "</secret>";
+		}
+
+		stream << "<processes>";
+		
+		for (it = processes.begin(); it != processes.end(); it++) {
+			stream << "<process>";
+			(*it)->inspectXml(stream, includeSecrets);
+			stream << "</process>";
+		}
+		
+		for (it = disabledProcesses.begin(); it != disabledProcesses.end(); it++) {
+			stream << "<process>";
+			(*it)->inspectXml(stream, includeSecrets);
+			stream << "</process>";
+		}
+
+		stream << "</processes>";
+	}
+};
+
+
+} // namespace ApplicationPool2
+} // namespace Passenger
+
+#endif /* _PASSENGER_APPLICATION_POOL2_GROUP_H_ */