passenger 2.0.6 → 2.1.2

data/ext/apache2/SpawnManager.h

@@ -24,6 +24,8 @@
 #include <list>
 #include <boost/shared_ptr.hpp>
 #include <boost/thread.hpp>
+#include <oxt/system_calls.hpp>
+#include <oxt/backtrace.hpp>
 
 #include <sys/types.h>
 #include <sys/wait.h>
@@ -33,19 +35,21 @@
 #include <cstdarg>
 #include <unistd.h>
 #include <errno.h>
+#include <grp.h>
 #include <pwd.h>
 #include <signal.h>
 
 #include "Application.h"
+#include "PoolOptions.h"
 #include "MessageChannel.h"
 #include "Exceptions.h"
 #include "Logging.h"
-#include "System.h"
 
 namespace Passenger {
 
 using namespace std;
 using namespace boost;
+using namespace oxt;
 
 /**
  * @brief Spawning of Ruby on Rails/Rack application instances.
@@ -89,7 +93,7 @@ private:
 	string rubyCommand;
 	string user;
 	
-	mutex lock;
+	boost::mutex lock;
 	
 	MessageChannel channel;
 	pid_t pid;
@@ -103,30 +107,34 @@ private:
 	 * @throws IOException The specified log file could not be opened.
 	 */
 	void restartServer() {
+		TRACE_POINT();
 		if (pid != 0) {
+			UPDATE_TRACE_POINT();
 			channel.close();
 			
 			// Wait at most 5 seconds for the spawn server to exit.
 			// If that doesn't work, kill it, then wait at most 5 seconds
 			// for it to exit.
-			time_t begin = InterruptableCalls::time(NULL);
+			time_t begin = syscalls::time(NULL);
 			bool done = false;
-			while (!done && InterruptableCalls::time(NULL) - begin < 5) {
-				if (InterruptableCalls::waitpid(pid, NULL, WNOHANG) > 0) {
+			while (!done && syscalls::time(NULL) - begin < 5) {
+				if (syscalls::waitpid(pid, NULL, WNOHANG) > 0) {
 					done = true;
 				} else {
-					InterruptableCalls::usleep(100000);
+					syscalls::usleep(100000);
 				}
 			}
+			UPDATE_TRACE_POINT();
 			if (!done) {
+				UPDATE_TRACE_POINT();
 				P_TRACE(2, "Spawn server did not exit in time, killing it...");
-				InterruptableCalls::kill(pid, SIGTERM);
-				begin = InterruptableCalls::time(NULL);
-				while (InterruptableCalls::time(NULL) - begin < 5) {
-					if (InterruptableCalls::waitpid(pid, NULL, WNOHANG) > 0) {
+				syscalls::kill(pid, SIGTERM);
+				begin = syscalls::time(NULL);
+				while (syscalls::time(NULL) - begin < 5) {
+					if (syscalls::waitpid(pid, NULL, WNOHANG) > 0) {
 						break;
 					} else {
-						InterruptableCalls::usleep(100000);
+						syscalls::usleep(100000);
 					}
 				}
 				P_TRACE(2, "Spawn server has exited.");
@@ -138,11 +146,11 @@ private:
 		FILE *logFileHandle = NULL;
 		
 		serverNeedsRestart = true;
-		if (InterruptableCalls::socketpair(AF_UNIX, SOCK_STREAM, 0, fds) == -1) {
+		if (syscalls::socketpair(AF_UNIX, SOCK_STREAM, 0, fds) == -1) {
 			throw SystemException("Cannot create a Unix socket", errno);
 		}
 		if (!logFile.empty()) {
-			logFileHandle = InterruptableCalls::fopen(logFile.c_str(), "a");
+			logFileHandle = syscalls::fopen(logFile.c_str(), "a");
 			if (logFileHandle == NULL) {
 				string message("Cannot open log file '");
 				message.append(logFile);
@@ -151,7 +159,8 @@ private:
 			}
 		}
 
-		pid = InterruptableCalls::fork();
+		UPDATE_TRACE_POINT();
+		pid = syscalls::fork();
 		if (pid == 0) {
 			if (!logFile.empty()) {
 				dup2(fileno(logFileHandle), STDERR_FILENO);
@@ -168,6 +177,14 @@ private:
 			if (!user.empty()) {
 				struct passwd *entry = getpwnam(user.c_str());
 				if (entry != NULL) {
+					if (initgroups(user.c_str(), entry->pw_gid) != 0) {
+						int e = errno;
+						fprintf(stderr, "*** Passenger: cannot set supplementary "
+							"groups for user %s: %s (%d)\n",
+							user.c_str(),
+							strerror(e),
+							e);
+					}
 					if (setgid(entry->pw_gid) != 0) {
 						int e = errno;
 						fprintf(stderr, "*** Passenger: cannot run spawn "
@@ -202,33 +219,35 @@ private:
 				// This argument is ignored by the spawn server. This works on some
 				// systems, such as Ubuntu Linux.
 				"                                                             ",
-				NULL);
+				(char *) NULL);
 			int e = errno;
-			fprintf(stderr, "*** Passenger ERROR: Could not start the spawn server: %s: %s (%d)\n",
+			fprintf(stderr, "*** Passenger ERROR (%s:%d):\n"
+				"Could not start the spawn server: %s: %s (%d)\n",
+				__FILE__, __LINE__,
 				rubyCommand.c_str(), strerror(e), e);
 			fflush(stderr);
 			_exit(1);
 		} else if (pid == -1) {
 			int e = errno;
-			InterruptableCalls::close(fds[0]);
-			InterruptableCalls::close(fds[1]);
+			syscalls::close(fds[0]);
+			syscalls::close(fds[1]);
 			if (logFileHandle != NULL) {
-				InterruptableCalls::fclose(logFileHandle);
+				syscalls::fclose(logFileHandle);
 			}
 			pid = 0;
 			throw SystemException("Unable to fork a process", e);
 		} else {
-			InterruptableCalls::close(fds[1]);
+			syscalls::close(fds[1]);
 			if (!logFile.empty()) {
-				InterruptableCalls::fclose(logFileHandle);
+				syscalls::fclose(logFileHandle);
 			}
 			channel = MessageChannel(fds[0]);
 			serverNeedsRestart = false;
 			
 			#ifdef TESTING_SPAWN_MANAGER
 				if (nextRestartShouldFail) {
-					InterruptableCalls::kill(pid, SIGTERM);
-					InterruptableCalls::usleep(500000);
+					syscalls::kill(pid, SIGTERM);
+					syscalls::usleep(500000);
 				}
 			#endif
 		}
@@ -237,41 +256,26 @@ private:
 	/**
 	 * Send the spawn command to the spawn server.
 	 *
-	 * @param appRoot The application root of the application to spawn.
-	 * @param lowerPrivilege Whether to lower the application's privileges.
-	 * @param lowestUser The user to fallback to if lowering privilege fails.
-	 * @param environment The RAILS_ENV/RACK_ENV environment that should be used.
-	 * @param spawnMethod The spawn method to use.
-	 * @param appType The application type.
+	 * @param PoolOptions The spawn options to use.
 	 * @return An Application smart pointer, representing the spawned application.
 	 * @throws SpawnException Something went wrong.
 	 */
-	ApplicationPtr sendSpawnCommand(
-		const string &appRoot,
-		bool lowerPrivilege,
-		const string &lowestUser,
-		const string &environment,
-		const string &spawnMethod,
-		const string &appType
-	) {
+	ApplicationPtr sendSpawnCommand(const PoolOptions &PoolOptions) {
+		TRACE_POINT();
 		vector<string> args;
 		int ownerPipe;
 		
 		try {
-			channel.write("spawn_application",
-				appRoot.c_str(),
-				(lowerPrivilege) ? "true" : "false",
-				lowestUser.c_str(),
-				environment.c_str(),
-				spawnMethod.c_str(),
-				appType.c_str(),
-				NULL);
+			args.push_back("spawn_application");
+			PoolOptions.toVector(args);
+			channel.write(args);
 		} catch (const SystemException &e) {
 			throw SpawnException(string("Could not write 'spawn_application' "
 				"command to the spawn server: ") + e.sys());
 		}
 		
 		try {
+			UPDATE_TRACE_POINT();
 			// Read status.
 			if (!channel.read(args)) {
 				throw SpawnException("The spawn server has exited unexpectedly.");
@@ -299,6 +303,7 @@ private:
 			throw SpawnException(string("Could not read from the spawn server: ") + e.sys());
 		}
 		
+		UPDATE_TRACE_POINT();
 		try {
 			ownerPipe = channel.readFileDescriptor();
 		} catch (const SystemException &e) {
@@ -312,14 +317,15 @@ private:
 		}
 		
 		if (args.size() != 3) {
-			InterruptableCalls::close(ownerPipe);
+			UPDATE_TRACE_POINT();
+			syscalls::close(ownerPipe);
 			throw SpawnException("The spawn server sent an invalid message.");
 		}
 		
 		pid_t pid = atoi(args[0]);
-		bool usingAbstractNamespace = args[2] == "true";
 		
-		if (!usingAbstractNamespace) {
+		UPDATE_TRACE_POINT();
+		if (args[2] == "unix") {
 			int ret;
 			do {
 				ret = chmod(args[1].c_str(), S_IRUSR | S_IWUSR);
@@ -328,18 +334,16 @@ private:
 				ret = chown(args[1].c_str(), getuid(), getgid());
 			} while (ret == -1 && errno == EINTR);
 		}
-		return ApplicationPtr(new Application(appRoot, pid, args[1],
-			usingAbstractNamespace, ownerPipe));
+		return ApplicationPtr(new Application(PoolOptions.appRoot,
+			pid, args[1], args[2], ownerPipe));
 	}
 	
 	/**
 	 * @throws boost::thread_interrupted
 	 */
 	ApplicationPtr
-	handleSpawnException(const SpawnException &e, const string &appRoot,
-	                     bool lowerPrivilege, const string &lowestUser,
-	                     const string &environment, const string &spawnMethod,
-	                     const string &appType) {
+	handleSpawnException(const SpawnException &e, const PoolOptions &PoolOptions) {
+		TRACE_POINT();
 		bool restarted;
 		try {
 			P_DEBUG("Spawn server died. Attempting to restart it...");
@@ -355,8 +359,7 @@ private:
 			restarted = false;
 		}
 		if (restarted) {
-			return sendSpawnCommand(appRoot, lowerPrivilege, lowestUser,
-				environment, spawnMethod, appType);
+			return sendSpawnCommand(PoolOptions);
 		} else {
 			throw SpawnException("The spawn server died unexpectedly, and restarting it failed.");
 		}
@@ -369,6 +372,7 @@ private:
 	 * @throws SystemException Something went wrong.
 	 */
 	void sendReloadCommand(const string &appRoot) {
+		TRACE_POINT();
 		try {
 			channel.write("reload", appRoot.c_str(), NULL);
 		} catch (const SystemException &e) {
@@ -378,6 +382,7 @@ private:
 	}
 	
 	void handleReloadException(const SystemException &e, const string &appRoot) {
+		TRACE_POINT();
 		bool restarted;
 		try {
 			P_DEBUG("Spawn server died. Attempting to restart it...");
@@ -434,6 +439,7 @@ public:
 	             const string &logFile = "",
 	             const string &rubyCommand = "ruby",
 	             const string &user = "") {
+		TRACE_POINT();
 		this->spawnServerCommand = spawnServerCommand;
 		this->logFile = logFile;
 		this->rubyCommand = rubyCommand;
@@ -454,76 +460,45 @@ public:
 	}
 	
 	~SpawnManager() throw() {
+		TRACE_POINT();
 		if (pid != 0) {
+			UPDATE_TRACE_POINT();
 			this_thread::disable_interruption di;
 			this_thread::disable_syscall_interruption dsi;
 			P_TRACE(2, "Shutting down spawn manager (PID " << pid << ").");
 			channel.close();
-			InterruptableCalls::waitpid(pid, NULL, 0);
+			syscalls::waitpid(pid, NULL, 0);
 			P_TRACE(2, "Spawn manager exited.");
 		}
 	}
 	
 	/**
-	 * Spawn a new instance of a Ruby on Rails or Rack application.
+	 * Spawn a new instance of an application. Spawning details are to be passed
+	 * via the <tt>PoolOptions</tt> parameter.
 	 *
 	 * If the spawn server died during the spawning process, then the server
 	 * will be automatically restarted, and another spawn attempt will be made.
 	 * If restarting the server fails, or if the second spawn attempt fails,
 	 * then an exception will be thrown.
 	 *
-	 * If <tt>lowerPrivilege</tt> is true, then it will be attempt to
-	 * switch the spawned application instance to the user who owns the
-	 * application's <tt>config/environment.rb</tt>, and to the default
-	 * group of that user.
-	 *
-	 * If that user doesn't exist on the system, or if that user is root,
-	 * then it will be attempted to switch to the username given by
-	 * <tt>lowestUser</tt> (and to the default group of that user).
-	 * If <tt>lowestUser</tt> doesn't exist either, or if switching user failed
-	 * (because the spawn server process does not have the privilege to do so),
-	 * then the application will be spawned anyway, without reporting an error.
-	 *
-	 * It goes without saying that lowering privilege is only possible if
-	 * the spawn server is running as root (and thus, by induction, that
-	 * Passenger and Apache's control process are also running as root).
-	 * Note that if Apache is listening on port 80, then its control process must
-	 * be running as root. See "doc/Security of user switching.txt" for
-	 * a detailed explanation.
-	 *
-	 * @param appRoot The application root of a RoR application, i.e. the folder that
-	 *             contains 'app/', 'public/', 'config/', etc. This must be a valid directory,
-	 *             but the path does not have to be absolute.
-	 * @param lowerPrivilege Whether to lower the application's privileges.
-	 * @param lowestUser The user to fallback to if lowering privilege fails.
-	 * @param environment The RAILS_ENV/RACK_ENV environment that should be used. May not be empty.
-	 * @param spawnMethod The spawn method to use. Either "smart" or "conservative".
-	 *                    See the Ruby class SpawnManager for details.
-	 * @param appType The application type. Either "rails" or "rack".
+	 * @param PoolOptions An object containing the details for this spawn operation,
+	 *                     such as which application to spawn. See PoolOptions for details.
 	 * @return A smart pointer to an Application object, which represents the application
 	 *         instance that has been spawned. Use this object to communicate with the
 	 *         spawned application.
 	 * @throws SpawnException Something went wrong.
 	 * @throws boost::thread_interrupted
 	 */
-	ApplicationPtr spawn(
-		const string &appRoot,
-		bool lowerPrivilege = true,
-		const string &lowestUser = "nobody",
-		const string &environment = "production",
-		const string &spawnMethod = "smart",
-		const string &appType = "rails"
-	) {
-		mutex::scoped_lock l(lock);
+	ApplicationPtr spawn(const PoolOptions &PoolOptions) {
+		TRACE_POINT();
+		boost::mutex::scoped_lock l(lock);
 		try {
-			return sendSpawnCommand(appRoot, lowerPrivilege, lowestUser,
-				environment, spawnMethod, appType);
+			return sendSpawnCommand(PoolOptions);
 		} catch (const SpawnException &e) {
 			if (e.hasErrorPage()) {
 				throw;
 			} else {
-				return handleSpawnException(e, appRoot, lowerPrivilege,
-					lowestUser, environment, spawnMethod, appType);
+				return handleSpawnException(e, PoolOptions);
 			}
 		}
 	}
@@ -544,6 +519,7 @@ public:
 	 *         restart was attempted, but it failed.
 	 */
 	void reload(const string &appRoot) {
+		TRACE_POINT();
 		this_thread::disable_interruption di;
 		this_thread::disable_syscall_interruption dsi;
 		try {

data/ext/apache2/StandardApplicationPool.h

@@ -27,6 +27,9 @@
 #include <boost/date_time/microsec_time_clock.hpp>
 #include <boost/date_time/posix_time/posix_time.hpp>
 
+#include <oxt/system_calls.hpp>
+#include <oxt/backtrace.hpp>
+
 #include <string>
 #include <sstream>
 #include <map>
@@ -44,7 +47,8 @@
 
 #include "ApplicationPool.h"
 #include "Logging.h"
-#include "System.h"
+#include "FileChecker.h"
+#include "CachedFileStat.h"
 #ifdef PASSENGER_USE_DUMMY_SPAWN_MANAGER
 	#include "DummySpawnManager.h"
 #else
@@ -55,6 +59,7 @@ namespace Passenger {
 
 using namespace std;
 using namespace boost;
+using namespace oxt;
 
 class ApplicationPoolServer;
 
@@ -99,37 +104,100 @@ private:
 	static const unsigned int GET_TIMEOUT = 5000; // In milliseconds.
 
 	friend class ApplicationPoolServer;
+	struct Domain;
 	struct AppContainer;
 	
+	typedef shared_ptr<Domain> DomainPtr;
 	typedef shared_ptr<AppContainer> AppContainerPtr;
 	typedef list<AppContainerPtr> AppContainerList;
-	typedef shared_ptr<AppContainerList> AppContainerListPtr;
-	typedef map<string, AppContainerListPtr> ApplicationMap;
+	typedef map<string, DomainPtr> DomainMap;
+	
+	struct Domain {
+		AppContainerList instances;
+		unsigned int size;
+		unsigned long maxRequests;
+		FileChecker restartFileChecker;
+		CachedFileStat alwaysRestartFileStatter;
+		
+		Domain(const PoolOptions &options)
+			: restartFileChecker(determineRestartDir(options) + "/restart.txt"),
+			  alwaysRestartFileStatter(determineRestartDir(options) + "/always_restart.txt")
+		{
+		}
+	
+	private:
+		static string determineRestartDir(const PoolOptions &options) {
+			if (options.restartDir.empty()) {
+				return options.appRoot + "/tmp";
+			} else if (options.restartDir[0] == '/') {
+				return options.restartDir;
+			} else {
+				return options.appRoot + "/" + options.restartDir;
+			}
+		}
+	};
 	
 	struct AppContainer {
 		ApplicationPtr app;
+		time_t startTime;
 		time_t lastUsed;
 		unsigned int sessions;
+		unsigned int processed;
 		AppContainerList::iterator iterator;
 		AppContainerList::iterator ia_iterator;
+		
+		AppContainer() {
+			startTime = time(NULL);
+			processed = 0;
+		}
+		
+		/**
+		 * Returns the uptime of this AppContainer so far, as a string.
+		 */
+		string uptime() const {
+			time_t seconds = time(NULL) - startTime;
+			stringstream result;
+			
+			if (seconds >= 60) {
+				time_t minutes = seconds / 60;
+				if (minutes >= 60) {
+					time_t hours = minutes / 60;
+					minutes = minutes % 60;
+					result << hours << "h ";
+				}
+				
+				seconds = seconds % 60;
+				result << minutes << "m ";
+			}
+			result << seconds << "s";
+			return result.str();
+		}
 	};
 	
+	/**
+	 * A data structure which contains data that's shared between a
+	 * StandardApplicationPool and a SessionCloseCallback object.
+	 * This is because the StandardApplicationPool's life time could be
+	 * different from a SessionCloseCallback's.
+	 */
 	struct SharedData {
-		mutex lock;
+		boost::mutex lock;
 		condition activeOrMaxChanged;
 		
-		ApplicationMap apps;
+		DomainMap domains;
 		unsigned int max;
 		unsigned int count;
 		unsigned int active;
 		unsigned int maxPerApp;
 		AppContainerList inactiveApps;
-		map<string, time_t> restartFileTimes;
 		map<string, unsigned int> appInstanceCount;
 	};
 	
 	typedef shared_ptr<SharedData> SharedDataPtr;
 	
+	/**
+	 * Function object which will be called when a session has been closed.
+	 */
 	struct SessionCloseCallback {
 		SharedDataPtr data;
 		weak_ptr<AppContainer> container;
@@ -141,28 +209,42 @@ private:
 		}
 		
 		void operator()() {
-			mutex::scoped_lock l(data->lock);
+			boost::mutex::scoped_lock l(data->lock);
 			AppContainerPtr container(this->container.lock());
 			
 			if (container == NULL) {
 				return;
 			}
 			
-			ApplicationMap::iterator it;
-			it = data->apps.find(container->app->getAppRoot());
-			if (it != data->apps.end()) {
-				AppContainerListPtr list(it->second);
-				container->lastUsed = time(NULL);
-				container->sessions--;
-				if (container->sessions == 0) {
-					list->erase(container->iterator);
-					list->push_front(container);
-					container->iterator = list->begin();
-					data->inactiveApps.push_back(container);
-					container->ia_iterator = data->inactiveApps.end();
-					container->ia_iterator--;
+			DomainMap::iterator it;
+			it = data->domains.find(container->app->getAppRoot());
+			if (it != data->domains.end()) {
+				Domain *domain = it->second.get();
+				AppContainerList *instances = &domain->instances;
+				
+				container->processed++;
+				if (domain->maxRequests > 0 && container->processed >= domain->maxRequests) {
+					instances->erase(container->iterator);
+					domain->size--;
+					if (instances->empty()) {
+						data->domains.erase(container->app->getAppRoot());
+					}
+					data->count--;
 					data->active--;
 					data->activeOrMaxChanged.notify_all();
+				} else {
+					container->lastUsed = time(NULL);
+					container->sessions--;
+					if (container->sessions == 0) {
+						instances->erase(container->iterator);
+						instances->push_front(container);
+						container->iterator = instances->begin();
+						data->inactiveApps.push_back(container);
+						container->ia_iterator = data->inactiveApps.end();
+						container->ia_iterator--;
+						data->active--;
+						data->activeOrMaxChanged.notify_all();
+					}
 				}
 			}
 		}
@@ -174,24 +256,22 @@ private:
 		SpawnManager spawnManager;
 	#endif
 	SharedDataPtr data;
-	thread *cleanerThread;
+	boost::thread *cleanerThread;
 	bool detached;
 	bool done;
-	bool useGlobalQueue;
 	unsigned int maxIdleTime;
 	unsigned int waitingOnGlobalQueue;
 	condition cleanerThreadSleeper;
 	
 	// Shortcuts for instance variables in SharedData. Saves typing in get().
-	mutex &lock;
+	boost::mutex &lock;
 	condition &activeOrMaxChanged;
-	ApplicationMap &apps;
+	DomainMap &domains;
 	unsigned int &max;
 	unsigned int &count;
 	unsigned int &active;
 	unsigned int &maxPerApp;
 	AppContainerList &inactiveApps;
-	map<string, time_t> &restartFileTimes;
 	map<string, unsigned int> &appInstanceCount;
 	
 	/**
@@ -199,25 +279,38 @@ private:
 	 */
 	bool inline verifyState() {
 	#if PASSENGER_DEBUG
-		// Invariant for _apps_.
-		ApplicationMap::const_iterator it;
-		for (it = apps.begin(); it != apps.end(); it++) {
-			AppContainerList *list = it->second.get();
-			P_ASSERT(!list->empty(), false, "List for '" << it->first << "' is nonempty.");
+		// Invariants for _domains_.
+		DomainMap::const_iterator it;
+		unsigned int totalSize = 0;
+		for (it = domains.begin(); it != domains.end(); it++) {
+			const string &appRoot = it->first;
+			Domain *domain = it->second.get();
+			AppContainerList *instances = &domain->instances;
+			
+			P_ASSERT(domain->size <= count, false,
+				"domains['" << appRoot << "'].size (" << domain->size <<
+				") <= count (" << count << ")");
+			totalSize += domain->size;
+			
+			// Invariants for Domain.
+			
+			P_ASSERT(!instances->empty(), false,
+				"domains['" << appRoot << "'].instances is nonempty.");
 			
 			AppContainerList::const_iterator prev_lit;
 			AppContainerList::const_iterator lit;
-			prev_lit = list->begin();
+			prev_lit = instances->begin();
 			lit = prev_lit;
 			lit++;
-			for (; lit != list->end(); lit++) {
+			for (; lit != instances->end(); lit++) {
 				if ((*prev_lit)->sessions > 0) {
 					P_ASSERT((*lit)->sessions > 0, false,
-						"List for '" << it->first <<
-						"' is sorted from nonactive to active");
+						"domains['" << appRoot << "'].instances "
+						"is sorted from nonactive to active");
 				}
 			}
 		}
+		P_ASSERT(totalSize == count, false, "(sum of all d.size in domains) == count");
 		
 		P_ASSERT(active <= count, false,
 			"active (" << active << ") < count (" << count << ")");
@@ -227,9 +320,7 @@ private:
 		return true;
 	}
 	
-	template<typename LockActionType>
-	string toString(LockActionType lockAction) const {
-		unique_lock<mutex> l(lock, lockAction);
+	string toStringWithoutLock() const {
 		stringstream result;
 		
 		result << "----------- General information -----------" << endl;
@@ -237,23 +328,27 @@ private:
 		result << "count    = " << count << endl;
 		result << "active   = " << active << endl;
 		result << "inactive = " << inactiveApps.size() << endl;
-		result << "Using global queue: " << (useGlobalQueue ? "yes" : "no") << endl;
 		result << "Waiting on global queue: " << waitingOnGlobalQueue << endl;
 		result << endl;
 		
-		result << "----------- Applications -----------" << endl;
-		ApplicationMap::const_iterator it;
-		for (it = apps.begin(); it != apps.end(); it++) {
-			AppContainerList *list = it->second.get();
+		result << "----------- Domains -----------" << endl;
+		DomainMap::const_iterator it;
+		for (it = domains.begin(); it != domains.end(); it++) {
+			Domain *domain = it->second.get();
+			AppContainerList *instances = &domain->instances;
 			AppContainerList::const_iterator lit;
 			
 			result << it->first << ": " << endl;
-			for (lit = list->begin(); lit != list->end(); lit++) {
+			for (lit = instances->begin(); lit != instances->end(); lit++) {
 				AppContainer *container = lit->get();
 				char buf[128];
 				
-				snprintf(buf, sizeof(buf), "PID: %-8d  Sessions: %d",
-					container->app->getPid(), container->sessions);
+				snprintf(buf, sizeof(buf),
+						"PID: %-5lu   Sessions: %-2u   Processed: %-5u   Uptime: %s",
+						(unsigned long) container->app->getPid(),
+						container->sessions,
+						container->processed,
+						container->uptime().c_str());
 				result << "  " << buf << endl;
 			}
 			result << endl;
@@ -261,45 +356,14 @@ private:
 		return result.str();
 	}
 	
-	bool needsRestart(const string &appRoot) {
-		string restartFile(appRoot);
-		restartFile.append("/tmp/restart.txt");
-		
-		struct stat buf;
-		bool result;
-		int ret;
-		
-		do {
-			ret = stat(restartFile.c_str(), &buf);
-		} while (ret == -1 && errno == EINTR);
-		if (ret == 0) {
-			do {
-				ret = unlink(restartFile.c_str());
-			} while (ret == -1 && (errno == EINTR || errno == EAGAIN));
-			if (ret == 0 || errno == ENOENT) {
-				restartFileTimes.erase(appRoot);
-				result = true;
-			} else {
-				map<string, time_t>::const_iterator it;
-				
-				it = restartFileTimes.find(appRoot);
-				if (it == restartFileTimes.end()) {
-					result = true;
-				} else {
-					result = buf.st_mtime != restartFileTimes[appRoot];
-				}
-				restartFileTimes[appRoot] = buf.st_mtime;
-			}
-		} else {
-			restartFileTimes.erase(appRoot);
-			result = false;
-		}
-		return result;
+	bool needsRestart(const string &appRoot, Domain *domain, const PoolOptions &options) {
+		return domain->alwaysRestartFileStatter.refresh(options.statThrottleRate) == 0
+		    || domain->restartFileChecker.changed(options.statThrottleRate);
 	}
 	
 	void cleanerThreadMainLoop() {
 		this_thread::disable_syscall_interruption dsi;
-		unique_lock<mutex> l(lock);
+		unique_lock<boost::mutex> l(lock);
 		try {
 			while (!done && !this_thread::interruption_requested()) {
 				xtime xt;
@@ -316,31 +380,31 @@ private:
 					}
 				}
 				
-				time_t now = InterruptableCalls::time(NULL);
+				time_t now = syscalls::time(NULL);
 				AppContainerList::iterator it;
 				for (it = inactiveApps.begin(); it != inactiveApps.end(); it++) {
 					AppContainer &container(*it->get());
 					ApplicationPtr app(container.app);
-					AppContainerListPtr appList(apps[app->getAppRoot()]);
+					Domain *domain = domains[app->getAppRoot()].get();
+					AppContainerList *instances = &domain->instances;
 					
-					if (now - container.lastUsed > (time_t) maxIdleTime) {
+					if (maxIdleTime > 0 &&  
+					   (now - container.lastUsed > (time_t) maxIdleTime)) {
 						P_DEBUG("Cleaning idle app " << app->getAppRoot() <<
 							" (PID " << app->getPid() << ")");
-						appList->erase(container.iterator);
+						instances->erase(container.iterator);
 						
 						AppContainerList::iterator prev = it;
 						prev--;
 						inactiveApps.erase(it);
 						it = prev;
 						
-						appInstanceCount[app->getAppRoot()]--;
+						domain->size--;
 						
 						count--;
 					}
-					if (appList->empty()) {
-						apps.erase(app->getAppRoot());
-						appInstanceCount.erase(app->getAppRoot());
-						data->restartFileTimes.erase(app->getAppRoot());
+					if (instances->empty()) {
+						domains.erase(app->getAppRoot());
 					}
 				}
 			}
@@ -350,34 +414,31 @@ private:
 	}
 	
 	/**
+	 * Spawn a new application instance, or use an existing one that's in the pool.
+	 *
 	 * @throws boost::thread_interrupted
 	 * @throws SpawnException
 	 * @throws SystemException
 	 */
-	pair<AppContainerPtr, AppContainerList *>
-	spawnOrUseExisting(
-		mutex::scoped_lock &l,
-		const string &appRoot,
-		bool lowerPrivilege,
-		const string &lowestUser,
-		const string &environment,
-		const string &spawnMethod,
-		const string &appType
-	) {
+	pair<AppContainerPtr, Domain *>
+	spawnOrUseExisting(boost::mutex::scoped_lock &l, const PoolOptions &options) {
 		beginning_of_function:
 		
+		TRACE_POINT();
 		this_thread::disable_interruption di;
 		this_thread::disable_syscall_interruption dsi;
+		const string &appRoot(options.appRoot);
 		AppContainerPtr container;
-		AppContainerList *list;
+		Domain *domain;
+		AppContainerList *instances;
 		
 		try {
-			ApplicationMap::iterator it(apps.find(appRoot));
+			DomainMap::iterator it(domains.find(appRoot));
 			
-			if (it != apps.end() && needsRestart(appRoot)) {
+			if (it != domains.end() && needsRestart(appRoot, it->second.get(), options)) {
 				AppContainerList::iterator it2;
-				list = it->second.get();
-				for (it2 = list->begin(); it2 != list->end(); it2++) {
+				instances = &it->second->instances;
+				for (it2 = instances->begin(); it2 != instances->end(); it2++) {
 					container = *it2;
 					if (container->sessions == 0) {
 						inactiveApps.erase(container->ia_iterator);
@@ -385,49 +446,50 @@ private:
 						active--;
 					}
 					it2--;
-					list->erase(container->iterator);
+					instances->erase(container->iterator);
 					count--;
 				}
-				apps.erase(appRoot);
-				appInstanceCount.erase(appRoot);
+				domains.erase(appRoot);
 				spawnManager.reload(appRoot);
-				it = apps.end();
+				it = domains.end();
 				activeOrMaxChanged.notify_all();
 			}
 			
-			if (it != apps.end()) {
-				list = it->second.get();
+			if (it != domains.end()) {
+				domain = it->second.get();
+				instances = &domain->instances;
 				
-				if (list->front()->sessions == 0) {
-					container = list->front();
-					list->pop_front();
-					list->push_back(container);
-					container->iterator = list->end();
+				if (instances->front()->sessions == 0) {
+					container = instances->front();
+					instances->pop_front();
+					instances->push_back(container);
+					container->iterator = instances->end();
 					container->iterator--;
 					inactiveApps.erase(container->ia_iterator);
 					active++;
 					activeOrMaxChanged.notify_all();
 				} else if (count >= max || (
-					maxPerApp != 0 && appInstanceCount[appRoot] >= maxPerApp )
+					maxPerApp != 0 && domain->size >= maxPerApp )
 					) {
-					if (useGlobalQueue) {
+					if (options.useGlobalQueue) {
+						UPDATE_TRACE_POINT();
 						waitingOnGlobalQueue++;
 						activeOrMaxChanged.wait(l);
 						waitingOnGlobalQueue--;
 						goto beginning_of_function;
 					} else {
-						AppContainerList::iterator it(list->begin());
-						AppContainerList::iterator smallest(list->begin());
+						AppContainerList::iterator it(instances->begin());
+						AppContainerList::iterator smallest(instances->begin());
 						it++;
-						for (; it != list->end(); it++) {
+						for (; it != instances->end(); it++) {
 							if ((*it)->sessions < (*smallest)->sessions) {
 								smallest = it;
 							}
 						}
 						container = *smallest;
-						list->erase(smallest);
-						list->push_back(container);
-						container->iterator = list->end();
+						instances->erase(smallest);
+						instances->push_back(container);
+						container->iterator = instances->end();
 						container->iterator--;
 					}
 				} else {
@@ -435,57 +497,57 @@ private:
 					{
 						this_thread::restore_interruption ri(di);
 						this_thread::restore_syscall_interruption rsi(dsi);
-						container->app = spawnManager.spawn(appRoot,
-							lowerPrivilege, lowestUser, environment,
-							spawnMethod, appType);
+						container->app = spawnManager.spawn(options);
 					}
 					container->sessions = 0;
-					list->push_back(container);
-					container->iterator = list->end();
+					instances->push_back(container);
+					container->iterator = instances->end();
 					container->iterator--;
-					appInstanceCount[appRoot]++;
+					domain->size++;
 					count++;
 					active++;
 					activeOrMaxChanged.notify_all();
 				}
 			} else {
 				if (active >= max) {
+					UPDATE_TRACE_POINT();
 					activeOrMaxChanged.wait(l);
 					goto beginning_of_function;
-				}
-				if (count == max) {
+				} else if (count == max) {
 					container = inactiveApps.front();
 					inactiveApps.pop_front();
-					list = apps[container->app->getAppRoot()].get();
-					list->erase(container->iterator);
-					if (list->empty()) {
-						apps.erase(container->app->getAppRoot());
-						restartFileTimes.erase(container->app->getAppRoot());
-						appInstanceCount.erase(container->app->getAppRoot());
+					domain = domains[container->app->getAppRoot()].get();
+					instances = &domain->instances;
+					instances->erase(container->iterator);
+					if (instances->empty()) {
+						domains.erase(container->app->getAppRoot());
 					} else {
-						appInstanceCount[container->app->getAppRoot()]--;
+						domain->size--;
 					}
 					count--;
 				}
+				
+				UPDATE_TRACE_POINT();
 				container = ptr(new AppContainer());
 				{
 					this_thread::restore_interruption ri(di);
 					this_thread::restore_syscall_interruption rsi(dsi);
-					container->app = spawnManager.spawn(appRoot, lowerPrivilege, lowestUser,
-						environment, spawnMethod, appType);
+					container->app = spawnManager.spawn(options);
 				}
 				container->sessions = 0;
-				it = apps.find(appRoot);
-				if (it == apps.end()) {
-					list = new AppContainerList();
-					apps[appRoot] = ptr(list);
-					appInstanceCount[appRoot] = 1;
+				it = domains.find(appRoot);
+				if (it == domains.end()) {
+					domain = new Domain(options);
+					domain->size = 1;
+					domain->maxRequests = options.maxRequests;
+					domains[appRoot] = ptr(domain);
 				} else {
-					list = it->second.get();
-					appInstanceCount[appRoot]++;
+					domain = it->second.get();
+					domain->size++;
 				}
-				list->push_back(container);
-				container->iterator = list->end();
+				instances = &domain->instances;
+				instances->push_back(container);
+				container->iterator = instances->end();
 				container->iterator--;
 				count++;
 				active++;
@@ -509,7 +571,7 @@ private:
 			throw SpawnException(message);
 		}
 		
-		return make_pair(container, list);
+		return make_pair(container, domain);
 	}
 	
 public:
@@ -529,7 +591,6 @@ public:
 	 *             running as root. If the empty string is given, or if
 	 *             the <tt>user</tt> is not a valid username, then
 	 *             the spawn manager will be run as the current user.
-	 * @param rubyCommand The Ruby interpreter's command.
 	 * @throws SystemException An error occured while trying to setup the spawn server.
 	 * @throws IOException The specified log file could not be opened.
 	 */
@@ -544,25 +605,24 @@ public:
 		data(new SharedData()),
 		lock(data->lock),
 		activeOrMaxChanged(data->activeOrMaxChanged),
-		apps(data->apps),
+		domains(data->domains),
 		max(data->max),
 		count(data->count),
 		active(data->active),
 		maxPerApp(data->maxPerApp),
 		inactiveApps(data->inactiveApps),
-		restartFileTimes(data->restartFileTimes),
 		appInstanceCount(data->appInstanceCount)
 	{
+		TRACE_POINT();
 		detached = false;
 		done = false;
 		max = DEFAULT_MAX_POOL_SIZE;
 		count = 0;
 		active = 0;
-		useGlobalQueue = false;
 		waitingOnGlobalQueue = 0;
 		maxPerApp = DEFAULT_MAX_INSTANCES_PER_APP;
 		maxIdleTime = DEFAULT_MAX_IDLE_TIME;
-		cleanerThread = new thread(
+		cleanerThread = new boost::thread(
 			bind(&StandardApplicationPool::cleanerThreadMainLoop, this),
 			CLEANER_THREAD_STACK_SIZE
 		);
@@ -572,7 +632,7 @@ public:
 		if (!detached) {
 			this_thread::disable_interruption di;
 			{
-				mutex::scoped_lock l(lock);
+				boost::mutex::scoped_lock l(lock);
 				done = true;
 				cleanerThreadSleeper.notify_one();
 			}
@@ -581,28 +641,27 @@ public:
 		delete cleanerThread;
 	}
 	
-	virtual Application::SessionPtr get(
-		const string &appRoot,
-		bool lowerPrivilege = true,
-		const string &lowestUser = "nobody",
-		const string &environment = "production",
-		const string &spawnMethod = "smart",
-		const string &appType = "rails"
-	) {
+	virtual Application::SessionPtr get(const string &appRoot) {
+		return ApplicationPool::get(appRoot);
+	}
+	
+	virtual Application::SessionPtr get(const PoolOptions &options) {
+		TRACE_POINT();
 		using namespace boost::posix_time;
 		unsigned int attempt = 0;
-		ptime timeLimit(get_system_time() + millisec(GET_TIMEOUT));
-		unique_lock<mutex> l(lock);
+		// TODO: We should probably add a timeout to the following
+		// lock. This way we can fail gracefully if the server's under
+		// rediculous load. Though I'm not sure how much it really helps.
+		unique_lock<boost::mutex> l(lock);
 		
 		while (true) {
 			attempt++;
 			
-			pair<AppContainerPtr, AppContainerList *> p(
-				spawnOrUseExisting(l, appRoot, lowerPrivilege, lowestUser,
-					environment, spawnMethod, appType)
+			pair<AppContainerPtr, Domain *> p(
+				spawnOrUseExisting(l, options)
 			);
-			AppContainerPtr &container(p.first);
-			AppContainerList &list(*p.second);
+			AppContainerPtr &container = p.first;
+			Domain *domain = p.second;
 
 			container->lastUsed = time(NULL);
 			container->sessions++;
@@ -610,13 +669,26 @@ public:
 			P_ASSERT(verifyState(), Application::SessionPtr(),
 				"State is valid:\n" << toString(false));
 			try {
+				UPDATE_TRACE_POINT();
 				return container->app->connect(SessionCloseCallback(data, container));
 			} catch (const exception &e) {
 				container->sessions--;
+				
+				AppContainerList &instances(domain->instances);
+				instances.erase(container->iterator);
+				domain->size--;
+				if (instances.empty()) {
+					domains.erase(options.appRoot);
+				}
+				count--;
+				active--;
+				activeOrMaxChanged.notify_all();
+				P_ASSERT(verifyState(), Application::SessionPtr(),
+					"State is valid: " << toString(false));
 				if (attempt == MAX_GET_ATTEMPTS) {
 					string message("Cannot connect to an existing "
 						"application instance for '");
-					message.append(appRoot);
+					message.append(options.appRoot);
 					message.append("': ");
 					try {
 						const SystemException &syse =
@@ -626,17 +698,6 @@ public:
 						message.append(e.what());
 					}
 					throw IOException(message);
-				} else {
-					list.erase(container->iterator);
-					if (list.empty()) {
-						apps.erase(appRoot);
-						appInstanceCount.erase(appRoot);
-					}
-					count--;
-					active--;
-					activeOrMaxChanged.notify_all();
-					P_ASSERT(verifyState(), Application::SessionPtr(),
-						"State is valid.");
 				}
 			}
 		}
@@ -645,10 +706,9 @@ public:
 	}
 	
 	virtual void clear() {
-		mutex::scoped_lock l(lock);
-		apps.clear();
+		boost::mutex::scoped_lock l(lock);
+		domains.clear();
 		inactiveApps.clear();
-		restartFileTimes.clear();
 		appInstanceCount.clear();
 		count = 0;
 		active = 0;
@@ -656,13 +716,13 @@ public:
 	}
 	
 	virtual void setMaxIdleTime(unsigned int seconds) {
-		mutex::scoped_lock l(lock);
+		boost::mutex::scoped_lock l(lock);
 		maxIdleTime = seconds;
 		cleanerThreadSleeper.notify_one();
 	}
 	
 	virtual void setMax(unsigned int max) {
-		mutex::scoped_lock l(lock);
+		boost::mutex::scoped_lock l(lock);
 		this->max = max;
 		activeOrMaxChanged.notify_all();
 	}
@@ -676,15 +736,11 @@ public:
 	}
 	
 	virtual void setMaxPerApp(unsigned int maxPerApp) {
-		mutex::scoped_lock l(lock);
+		boost::mutex::scoped_lock l(lock);
 		this->maxPerApp = maxPerApp;
 		activeOrMaxChanged.notify_all();
 	}
 	
-	virtual void setUseGlobalQueue(bool value) {
-		this->useGlobalQueue = value;
-	}
-	
 	virtual pid_t getSpawnServerPid() const {
 		return spawnManager.getServerPid();
 	}
@@ -695,13 +751,58 @@ public:
 	 */
 	virtual string toString(bool lockMutex = true) const {
 		if (lockMutex) {
-			return toString(boost::adopt_lock);
+			unique_lock<boost::mutex> l(lock);
+			return toStringWithoutLock();
 		} else {
-			return toString(boost::defer_lock);
+			return toStringWithoutLock();
 		}
 	}
+	
+	/**
+	 * Returns an XML description of the internal state of the
+	 * application pool.
+	 */
+	virtual string toXml() const {
+		unique_lock<boost::mutex> l(lock);
+		stringstream result;
+		DomainMap::const_iterator it;
+		
+		result << "<?xml version=\"1.0\" encoding=\"iso8859-1\" ?>\n";
+		result << "<info>";
+		
+		result << "<domains>";
+		for (it = domains.begin(); it != domains.end(); it++) {
+			Domain *domain = it->second.get();
+			AppContainerList *instances = &domain->instances;
+			AppContainerList::const_iterator lit;
+			
+			result << "<domain>";
+			result << "<name>" << escapeForXml(it->first) << "</name>";
+			
+			result << "<instances>";
+			for (lit = instances->begin(); lit != instances->end(); lit++) {
+				AppContainer *container = lit->get();
+				
+				result << "<instance>";
+				result << "<pid>" << container->app->getPid() << "</pid>";
+				result << "<sessions>" << container->sessions << "</sessions>";
+				result << "<processed>" << container->processed << "</processed>";
+				result << "<uptime>" << container->uptime() << "</uptime>";
+				result << "</instance>";
+			}
+			result << "</instances>";
+			
+			result << "</domain>";
+		}
+		result << "</domains>";
+		
+		result << "</info>";
+		return result.str();
+	}
 };
 
+typedef shared_ptr<StandardApplicationPool> StandardApplicationPoolPtr;
+
 } // namespace Passenger
 
 #endif /* _PASSENGER_STANDARD_APPLICATION_POOL_H_ */