passenger 2.2.15 → 3.0.0.pre1

data/lib/phusion_passenger/wsgi/application_spawner.rb

@@ -1,5 +1,5 @@
 #  Phusion Passenger - http://www.modrails.com/
-#  Copyright (c) 2008, 2009 Phusion
+#  Copyright (c) 2010 Phusion
 #
 #  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
 #
@@ -22,9 +22,13 @@
 #  THE SOFTWARE.
 
 require 'socket'
-require 'phusion_passenger/application'
+require 'phusion_passenger/app_process'
 require 'phusion_passenger/message_channel'
+require 'phusion_passenger/public_api'
 require 'phusion_passenger/utils'
+require 'phusion_passenger/utils/tmpdir'
+require 'phusion_passenger/native_support'
+
 module PhusionPassenger
 module WSGI
 
@@ -46,7 +50,7 @@ class ApplicationSpawner
 	# - AppInitError: The WSGI application raised an exception or called
 	#   exit() during startup.
 	# - SystemCallError, IOError, SocketError: Something went wrong.
-	def spawn_application(app_root, lower_privilege = true, lowest_user = "nobody", environment = "production")
+	def spawn_application(options)
 		a, b = UNIXSocket.pair
 		pid = safe_fork(self.class.to_s, true) do
 			a.close
@@ -55,36 +59,36 @@ class ApplicationSpawner
 			NativeSupport.close_all_file_descriptors(file_descriptors_to_leave_open)
 			close_all_io_objects_for_fds(file_descriptors_to_leave_open)
 			
-			run(MessageChannel.new(b), app_root, lower_privilege, lowest_user, environment)
+			run(MessageChannel.new(b), options)
 		end
 		b.close
 		Process.waitpid(pid) rescue nil
 		
 		channel = MessageChannel.new(a)
-		pid, socket_name, socket_type = channel.read
-		if pid.nil?
-			raise IOError, "Connection closed"
-		end
-		owner_pipe = channel.recv_io
-		return Application.new(@app_root, pid, socket_name,
-			socket_type, owner_pipe)
+		return AppProcess.read_from_channel(channel)
 	end
 
 private
-	def run(channel, app_root, lower_privilege, lowest_user, environment)
-		$0 = "WSGI: #{app_root}"
-		ENV['WSGI_ENV'] = environment
-		Dir.chdir(app_root)
-		if lower_privilege
-			lower_privilege('passenger_wsgi.py', lowest_user)
+	def run(channel, options)
+		$0 = "WSGI: #{options['app_root']}"
+		prepare_app_process("passenger_wsgi.py", options)
+		ENV['WSGI_ENV'] = options['environment']
+		
+		if defined?(NativeSupport)
+			unix_path_max = NativeSupport::UNIX_PATH_MAX
+		else
+			unix_path_max = 100
 		end
 		
-		socket_file = "#{passenger_tmpdir}/backends/wsgi_backend.#{Process.pid}.#{rand 10000000}"
+		socket_file = "#{passenger_tmpdir}/backends/wsgi.#{Process.pid}.#{rand 10000000}"
+		socket_file = socket_file.slice(0, unix_path_max - 1)
 		server = UNIXServer.new(socket_file)
 		begin
+			File.chmod(0666, socket_file)
 			reader, writer = IO.pipe
-			channel.write(Process.pid, socket_file, "unix")
-			channel.send_io(writer)
+			app_process = AppProcess.new(options["app_root"], Process.pid, writer,
+				:main => [socket_file, 'unix'])
+			app_process.write_to_channel(channel)
 			writer.close
 			channel.close
 			

data/lib/phusion_passenger/wsgi/request_handler.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python
 #  Phusion Passenger - http://www.modrails.com/
-#  Copyright (c) 2008, 2009 Phusion
+#  Copyright (c) 2010 Phusion
 #
 #  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
 #

data/misc/copy_boost_headers.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 #  Phusion Passenger - http://www.modrails.com/
-#  Copyright (c) 2008, 2009 Phusion
+#  Copyright (c) 2010 Phusion
 #
 #  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
 #
@@ -25,17 +25,30 @@
 ESSENTIALS = [
 	"boost/detail/{limits,endian}.hpp",
 	"boost/config/*",
-	"boost/detail/sp_counted_*",
-	"boost/detail/atomic_count*",
-	"libs/thread/src/*"
+	"boost/smart_ptr/detail/sp_counted_*",
+	"boost/smart_ptr/detail/atomic_count*",
+	"boost/smart_ptr/detail/spinlock*",
+	"boost/thread/*",
+	"boost/thread/*/*",
+	"libs/thread/src/*",
+	"boost/date_time/gregorian/formatters_limited.hpp",
+	"boost/date_time/date_formatting_limited.hpp",
+	"boost/non_type.hpp"
+]
+EXCLUDE = [
+	"libs/thread/src/win32/*"
 ]
 PROGRAM_SOURCE = %q{
 	#include <boost/shared_ptr.hpp>
+	#include <boost/weak_ptr.hpp>
 	#include <boost/thread.hpp>
+	#include <boost/noncopyable.hpp>
 	#include <boost/function.hpp>
 	#include <boost/bind.hpp>
 	#include <boost/date_time/posix_time/posix_time.hpp>
 }
+
+require 'fileutils'
 BOOST_DIR = ARGV[0]
 Dir.chdir(File.dirname(__FILE__) + "/../ext")
 
@@ -49,16 +62,22 @@ def sh(*command)
 end
 
 def install(source_filename, target_filename)
-	command = ["install", "-D", "--mode=u+rw,g+r,o+r", source_filename, target_filename]
+	dir = File.dirname(target_filename)
+	if !File.exist?(dir)
+		sh "mkdir", "-p", dir
+	end
+	command = ["install", "-m", "u+rw,g+r,o+r", source_filename, target_filename]
 	sh(*command)
 end
 
-def copy_boost_files(*patterns)
+def copy_boost_files(patterns, exclude = nil)
 	patterns.each do |pattern|
-		Dir["#{BOOST_DIR}/#{pattern}"].each do |source|
+		files = Dir["#{BOOST_DIR}/#{pattern}"]
+		files -= exclude if exclude
+		files.each do |source|
 			if File.directory?(source)
 				source.slice!(0 .. BOOST_DIR.size)
-				copy_boost_files("#{source}/*")
+				copy_boost_files(["#{source}/*"], exclude)
 			else
 				target = source.slice(BOOST_DIR.size + 1 .. source.size - 1)
 				target.sub!(%r{^libs/thread/}, 'boost/')
@@ -71,7 +90,11 @@ def copy_boost_files(*patterns)
 end
 
 def copy_essential_files
-	copy_boost_files(*ESSENTIALS)
+	exclude = []
+	EXCLUDE.each do |pattern|
+		exclude.concat(Dir["#{BOOST_DIR}/#{pattern}"])
+	end
+	copy_boost_files(ESSENTIALS, exclude)
 end
 
 def prepare
@@ -81,6 +104,10 @@ def prepare
 end
 
 def cleanup
+	FileUtils.rm_rf("boost/thread/win32")
+	FileUtils.rm_rf("boost/src/win32")
+	FileUtils.rm_rf("boost/asio/win32")
+	FileUtils.rm_rf("boost/smart_ptr/detail/spinlock_w32.hpp")
 	File.unlink("test.cpp") rescue nil
 end
 

data/misc/find_owner_pipe_leaks.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 #  Phusion Passenger - http://www.modrails.com/
-#  Copyright (c) 2008, 2009 Phusion
+#  Copyright (c) 2010 Phusion
 #
 #  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
 #

data/misc/render_error_pages.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 #  Phusion Passenger - http://www.modrails.com/
-#  Copyright (c) 2008, 2009 Phusion
+#  Copyright (c) 2010 Phusion
 #
 #  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
 #

data/misc/union_station_gateway.crt

@@ -0,0 +1,32 @@
+-----BEGIN CERTIFICATE-----
+MIIFbjCCA1YCCQCd2BBmpGM9zDANBgkqhkiG9w0BAQUFADB5MQswCQYDVQQGEwJO
+TDESMBAGA1UECBMJTmVkZXJsYW5kMRAwDgYDVQQKEwdQaHVzaW9uMSQwIgYDVQQD
+ExtnYXRld2F5LnVuaW9uc3RhdGlvbmFwcC5jb20xHjAcBgkqhkiG9w0BCQEWD2lu
+Zm9AcGh1c2lvbi5ubDAeFw0xMDA4MDkwOTU2MzVaFw0zNzEyMjQwOTU2MzVaMHkx
+CzAJBgNVBAYTAk5MMRIwEAYDVQQIEwlOZWRlcmxhbmQxEDAOBgNVBAoTB1BodXNp
+b24xJDAiBgNVBAMTG2dhdGV3YXkudW5pb25zdGF0aW9uYXBwLmNvbTEeMBwGCSqG
+SIb3DQEJARYPaW5mb0BwaHVzaW9uLm5sMIICIjANBgkqhkiG9w0BAQEFAAOCAg8A
+MIICCgKCAgEAvUjNLupLtz8IIQINJ1XaLmR+ttTOvrGx/Y++BggI3LqAHwMsWjG4
+KIFhIpLfURViotthfbIYin3sPhC3WwvMfIoxezjAOnsXVcYB8ynxopu8WM4QSYLC
+64uAKyYlaHckxmppqGCBHtA+hHBLEDM/GO8hyJUn+Tjf0LEoranpfTLnZex9eMEo
+Ggx08saKZ6A2JLQbMEPOf62DQciwI8ToK8eV1WSrg6O7fVuLe9YPXVeqT3hFGhYX
+UXEFBFQs8EZDtEZvNCGyD3W3wnanQL/IGTm5BAiVVJoXnvXZoHMgX8ar2xQk1+t6
+Wvd0nMF/3tWVPW3mQTDYErRpXx7m+ySwYp72yidk7IlFkFW/OIJIiHLMUnwlu9fv
+PWlmNLVuubR5eu1/8Qb3hVPlqYFS/2nQRs4bYoO3r0enGY9V7deWtEeUuDlY5Y5C
+Bf/bSf0Kt6vSt0Y9obu2xQDIwl6OBnIXpuxSSVinh+31ECymolUFUbWEuEqkRKPY
+6UYjyex6az2dIMnrr9WF1lfT+GTq4rZa4wmymT00sVofceI/TPFoglhkq93rnLix
+TdUMnrywk3JUpGj1fsOI+PzGReUaJfR+4Gbau5Kab3ZKURQnY6toCQafaSGYJnO8
+rdpWbhJOTLO82K71W7+Dqw4bzpWyU2PJAiEO5w6mD3G/es+iAPrt64ECAwEAATAN
+BgkqhkiG9w0BAQUFAAOCAgEAQ2lkVAHv5SjCTeuKl93wSanxLL8zrvyh2DVYQc/b
+v/PSCL3Afoidlvjc1qVCB93WfIHTPGG/xOI0EVi8W96Zg9D6P8Kjc79Vfs6MM8h/
+vuHh4pS/PFTzmFd9nRI26iWMZl2DMQnXflSNJbxqWr0AtGZTnT9w/MR+2Kxu74AD
+E0r3P11WoYpfWVc6SiEBJ9WnMlSoAT+xShIiXAsLuzoXQOMGfg5M3JIsXwQZtRGN
+n58bq+prHroI1cU96xbmCw0fRgLuJYhdoU3uWE7usSutYaW7LT4T2oGR5x2ZPzy/
+vr7jX8AbUJDWK3FbZ0//Zpkt9ldF60NJ/l42U6F5frQ+FSCDTX1k32RcG1vRIfM5
+TZgBgT0D3AJoNPbNaEGWsBrxG3wZGxxvnamPM0S01WmxwL2PNM1UnUKG+y/ALfoc
+JJeXyuY3HFt3DyYE4odyPOHye/fP1qLl1ZrJIzyAT0pUo38UB8uQ4HZUWD/LljJm
+V0fUFWKWk6OawwIM4sYc90WezYgDfAT1RUDy0TnvKlG4FC1Oodnnm2rQFu+zDOWH
+Fj0lBkzVUOlt2nWhLIW/uN3bjM9TsXaw8qUGWhvn4z3FHGHEdnLy3wMzwCSVq1tg
+QilKaQe+8Y4SePo110Tmkfls6vyEhcN6KpRWdpQSXUXmMY7IxjfNJnKTeGvWd1Y9
+CaY=
+-----END CERTIFICATE-----

data/test/config.yml.example

@@ -1,27 +1,38 @@
 ### This file contains system-specific configuration options that the test suite needs.
 ### Please customize it for your system.
 
-# These are the user names of two normal, non-administrator users.
-# Preferably, these are user accounts that are normally not used.
+# These are the usernames and group names of normal, non-administrator
+# users and groups. Preferably, these are user and group accounts that
+# are normally not used.
 #
-# NOTE: these users MUST be able to access this 'test' directory,
+# These users and groups MUST be able to access this 'test' directory,
 # otherwise the tests will fail.
+
+### Good values for Linux and FreeBSD:
 normal_user_1: games
 normal_user_2: daemon
+# Must not be "nobody".
+default_user: man
+# Must not be normal_user_1's primary group.
+normal_group_1: daemon
+# Must not be normal_user_2's primary group.
+normal_group_2: man
+# Must not be default_user's primary group. Must not be "nobody".
+default_group: games
 
-# The username of a user that has less privileges than a normal user.
-#
-# NOTES:
-# - this user MUST be able to access this 'test' directory, otherwise
-#   the tests will fail.
-# - this user MUST NOT have a negative UID value. So on OS X, this may
-#   not be the 'nobody' user.
-lowest_user: nobody
+### Good values for OS X. Same restrictions apply.
+# normal_user_1: _www
+# normal_user_2: daemon
+# default_user: _sandbox
+# normal_group_1: daemon
+# normal_group_2: _sandbox
+# default_group: _www
 
-# A nonexistant username.
+# A nonexistant username, group name, user ID and group ID.
 nonexistant_user: xxxxxxxxxxxxxxxxxxx
-# A nonexistant user ID.
+nonexistant_group: xxxxxxxxxxxxxxxxxxx
 nonexistant_uid: 9999
+nonexistant_gid: 9999
 
 
 # If you want to run the Nginx integration tests, then set the following

data/test/cxx/ApplicationPool_PoolTest.cpp

@@ -0,0 +1,33 @@
+#include "TestSupport.h"
+#include "ApplicationPool/Pool.h"
+#include "Utils.h"
+
+using namespace Passenger;
+
+namespace tut {
+	struct ApplicationPool_PoolTest {
+		ServerInstanceDirPtr serverInstanceDir;
+		ServerInstanceDir::GenerationPtr generation;
+		ApplicationPool::Ptr pool, pool2;
+		
+		ApplicationPool_PoolTest() {
+			createServerInstanceDirAndGeneration(serverInstanceDir, generation);
+			pool = ptr(new ApplicationPool::Pool("../helper-scripts/passenger-spawn-server", generation));
+			pool2 = pool;
+		}
+		
+		ApplicationPool::Ptr newPoolConnection() {
+			return pool;
+		}
+		
+		void reinitializeWithSpawnManager(AbstractSpawnManagerPtr spawnManager) {
+			pool = ptr(new ApplicationPool::Pool(spawnManager));
+			pool2 = pool;
+		}
+	};
+
+	DEFINE_TEST_GROUP(ApplicationPool_PoolTest);
+
+	#define USE_TEMPLATE
+	#include "ApplicationPool_PoolTestCases.cpp"
+}

data/test/cxx/ApplicationPool_PoolTestCases.cpp

@@ -0,0 +1,1029 @@
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <cstring>
+#include <cstdlib>
+#include <cerrno>
+#include <sys/types.h>
+#include <signal.h>
+#include <utime.h>
+
+/**
+ * This file is used as a template to test the different ApplicationPool::Interface implementations.
+ * It is #included in ApplicationPool_PoolTest.cpp and ApplicationPool_Server_PoolTest.cpp
+ */
+#ifdef USE_TEMPLATE
+	static void sendTestRequest(SessionPtr &session, const char *uri = "/foo/new") {
+		string headers;
+		#define ADD_HEADER(name, value) \
+			headers.append(name); \
+			headers.append(1, '\0'); \
+			headers.append(value); \
+			headers.append(1, '\0')
+		ADD_HEADER("HTTP_HOST", "www.test.com");
+		ADD_HEADER("QUERY_STRING", "");
+		ADD_HEADER("REQUEST_URI", uri);
+		ADD_HEADER("REQUEST_METHOD", "GET");
+		ADD_HEADER("REMOTE_ADDR", "localhost");
+		ADD_HEADER("SCRIPT_NAME", "");
+		ADD_HEADER("PATH_INFO", uri);
+		ADD_HEADER("PASSENGER_CONNECT_PASSWORD", session->getConnectPassword());
+		session->sendHeaders(headers);
+	}
+	
+	static SessionPtr spawnRackApp(ApplicationPool::Ptr pool, const char *appRoot) {
+		PoolOptions options;
+		options.appRoot = appRoot;
+		options.appType = "rack";
+		return pool->get(options);
+	}
+	
+	static SessionPtr spawnWsgiApp(ApplicationPool::Ptr pool, const char *appRoot) {
+		PoolOptions options;
+		options.appRoot = appRoot;
+		options.appType = "wsgi";
+		return pool->get(options);
+	}
+	
+	namespace {
+		class ReloadLoggingSpawnManager: public SpawnManager {
+		public:
+			vector<string> reloadLog;
+			
+			ReloadLoggingSpawnManager(const string &spawnServerCommand,
+				const ServerInstanceDir::GenerationPtr &generation,
+				const AccountsDatabasePtr &accountsDatabase = AccountsDatabasePtr(),
+				const string &rubyCommand = "ruby")
+			: SpawnManager(spawnServerCommand, generation, accountsDatabase, rubyCommand)
+			{ }
+			
+			virtual void reload(const string &appRoot) {
+				reloadLog.push_back(appRoot);
+				SpawnManager::reload(appRoot);
+			}
+		};
+		
+		struct SpawnRackAppFunction {
+			ApplicationPool::Ptr pool;
+			bool *done;
+			SessionPtr *session;
+			
+			SpawnRackAppFunction() {
+				done    = NULL;
+				session = NULL;
+			}
+
+			void operator()() {
+				PoolOptions options;
+				options.appRoot = "stub/rack";
+				options.appType = "rack";
+				options.useGlobalQueue = true;
+				SessionPtr session = pool->get(options);
+				*done = true;
+				if (this->session != NULL) {
+					*this->session = session;
+				}
+			}
+		};
+	}
+	
+	TEST_METHOD(1) {
+		// Calling ApplicationPool.get() once should return a valid Session.
+		SessionPtr session(spawnRackApp(pool, "stub/rack"));
+		sendTestRequest(session);
+		session->shutdownWriter();
+
+		int reader = session->getStream();
+		string result(readAll(reader));
+		session->closeStream();
+		ensure(result.find("hello <b>world</b>") != string::npos);
+	}
+	
+	TEST_METHOD(2) {
+		// Verify that the pool spawns a new app, and that
+		// after the session is closed, the app is kept around.
+		SessionPtr session(spawnRackApp(pool, "stub/rack"));
+		ensure_equals("Before the session was closed, the app was busy", pool->getActive(), 1u);
+		ensure_equals("Before the session was closed, the app was in the pool", pool->getCount(), 1u);
+		session.reset();
+		ensure_equals("After the session is closed, the app is no longer busy", pool->getActive(), 0u);
+		ensure_equals("After the session is closed, the app is kept around", pool->getCount(), 1u);
+	}
+	
+	TEST_METHOD(3) {
+		// If we call get() with an application root, then we close the session,
+		// and then we call get() again with the same app group name,
+		// then the pool should not have spawned more than 1 app in total.
+		SessionPtr session(spawnRackApp(pool, "stub/rack"));
+		session.reset();
+		session = spawnRackApp(pool, "stub/rack");
+		ensure_equals(pool->getCount(), 1u);
+	}
+	
+	TEST_METHOD(4) {
+		// If we call get() with an app group name, then we call get() again before closing
+		// the session, then the pool will eventually have spawned 2 apps in total.
+		SessionPtr session(spawnRackApp(pool, "stub/rack"));
+		SessionPtr session2(spawnRackApp(pool2, "stub/rack"));
+		EVENTUALLY(5,
+			result = pool->getCount() == 2u;
+		);
+	}
+	
+	TEST_METHOD(5) {
+		// If we call get() twice with different app group names,
+		// then the pool should spawn two different apps.
+		TempDirCopy c1("stub/rack", "rackapp1.tmp");
+		TempDirCopy c2("stub/rack", "rackapp2.tmp");
+		replaceStringInFile("rackapp2.tmp/config.ru", "world", "world 2");
+		SessionPtr session = spawnRackApp(pool, "rackapp1.tmp");
+		SessionPtr session2 = spawnRackApp(pool2, "rackapp2.tmp");
+		ensure_equals("Before the sessions were closed, both apps were busy", pool->getActive(), 2u);
+		ensure_equals("Before the sessions were closed, both apps were in the pool", pool->getCount(), 2u);
+		
+		sendTestRequest(session);
+		string result = readAll(session->getStream());
+		ensure("Session 1 belongs to the correct app", result.find("hello <b>world</b>") != string::npos);
+		session.reset();
+		
+		sendTestRequest(session2);
+		result = readAll(session2->getStream());
+		ensure("Session 2 belongs to the correct app", result.find("hello <b>world 2</b>") != string::npos);
+		session2.reset();
+	}
+	
+	TEST_METHOD(6) {
+		// If we call get() twice with different app group names,
+		// and we close both sessions, then both 2 apps should still
+		// be in the pool.
+		TempDirCopy c1("stub/rack", "rackapp1.tmp");
+		TempDirCopy c2("stub/rack", "rackapp2.tmp");
+		SessionPtr session(spawnRackApp(pool, "rackapp1.tmp"));
+		SessionPtr session2(spawnRackApp(pool, "rackapp2.tmp"));
+		session.reset();
+		session2.reset();
+		ensure_equals("There are 0 active apps", pool->getActive(), 0u);
+		ensure_equals("There are 2 apps in total", pool->getCount(), 2u);
+	}
+	
+	TEST_METHOD(7) {
+		// If we call get() even though the pool is already full
+		// (active == max), and the app group name is already
+		// in the pool, then the pool must wait until there's an
+		// inactive application.
+		pool->setMax(1);
+		// TODO: How do we test this?
+	}
+	
+	TEST_METHOD(8) {
+		// If ApplicationPool spawns a new instance,
+		// and we kill it, then the next get() with the
+		// same application root should not throw an exception:
+		// ApplicationPool should spawn a new instance
+		// after detecting that the original one died.
+		SessionPtr session = spawnRackApp(pool, "stub/rack");
+		kill(session->getPid(), SIGKILL);
+		session.reset();
+		usleep(20000); // Give the process some time to exit.
+		spawnRackApp(pool, "stub/rack"); // should not throw
+	}
+	
+	struct PoolWaitTestThread {
+		ApplicationPool::Ptr pool;
+		SessionPtr &m_session;
+		bool &m_done;
+		
+		PoolWaitTestThread(const ApplicationPool::Ptr &pool,
+			SessionPtr &session,
+			bool &done)
+		: m_session(session), m_done(done) {
+			this->pool = pool;
+			done = false;
+		}
+		
+		void operator()() {
+			m_session = spawnWsgiApp(pool, "stub/wsgi");
+			m_done = true;
+		}
+	};
+
+	TEST_METHOD(9) {
+		// If we call get() even though the pool is already full
+		// (active == max), and the app group name is *not* already
+		// in the pool, then the pool will wait until enough sessions
+		// have been closed.
+		
+		// Make the pool full.
+		pool->setMax(2);
+		SessionPtr session1 = spawnRackApp(pool, "stub/rack");
+		SessionPtr session2 = spawnRackApp(pool2, "stub/rack");
+		EVENTUALLY(5,
+			result = pool->getCount() == 2u;
+		);
+		session1.reset();
+		session2.reset();
+		EVENTUALLY(5,
+			result = pool->getActive() == 0u;
+		);
+		session1 = spawnRackApp(pool, "stub/rack");
+		session2 = spawnRackApp(pool2, "stub/rack");
+		ensure_equals(pool->getActive(), 2u);
+		
+		// Now spawn an app with a different app root.
+		SessionPtr session3;
+		bool done;
+		TempThread thr(PoolWaitTestThread(pool2, session3, done));
+		usleep(500000);
+		ensure("ApplicationPool is still waiting", !done);
+		ensure_equals(pool->getActive(), 2u);
+		ensure_equals(pool->getCount(), 2u);
+		
+		// Now release one slot from the pool.
+		session1.reset();
+		
+		// Session 3 should eventually be opened.
+		EVENTUALLY(10,
+			result = done;
+		);
+		ensure_equals(pool->getActive(), 2u);
+		ensure_equals(pool->getCount(), 2u);
+	}
+	
+	TEST_METHOD(10) {
+		// If we call get(), and:
+		// * the pool is already full, but there are inactive apps
+		//   (active < count && count == max)
+		// and
+		// * the app group name for this get() is *not* already in the pool
+		// then the an inactive app should be killed in order to
+		// satisfy this get() command.
+		TempDirCopy c1("stub/rack", "rackapp1.tmp");
+		TempDirCopy c2("stub/rack", "rackapp2.tmp");
+		
+		// Make the pool full.
+		pool->setMax(2);
+		SessionPtr session1 = spawnRackApp(pool, "rackapp1.tmp");
+		SessionPtr session2 = spawnRackApp(pool2, "rackapp1.tmp");
+		EVENTUALLY(5,
+			result = pool->getCount() == 2u;
+		);
+		session1.reset();
+		session2.reset();
+		EVENTUALLY(5,
+			result = pool->getActive() == 0u;
+		);
+		
+		// Now spawn a different app.
+		session1 = spawnRackApp(pool, "rackapp2.tmp");
+		ensure_equals(pool->getActive(), 1u);
+		ensure_equals(pool->getCount(), 2u);
+	}
+	
+	TEST_METHOD(11) {
+		// A Session should still be usable after the pool has been destroyed.
+		SessionPtr session = spawnRackApp(pool, "stub/rack");
+		pool->clear();
+		pool.reset();
+		pool2.reset();
+		
+		sendTestRequest(session);
+		session->shutdownWriter();
+		
+		int reader = session->getStream();
+		string result = readAll(reader);
+		session->closeStream();
+		ensure(result.find("hello <b>world</b>") != string::npos);
+	}
+	
+	TEST_METHOD(12) {
+		// If tmp/restart.txt didn't exist but has now been created,
+		// then the applications under app_root should be restarted.
+		struct stat buf;
+		TempDirCopy c("stub/rack", "rackapp.tmp");
+		SessionPtr session1 = spawnRackApp(pool, "rackapp.tmp");
+		SessionPtr session2 = spawnRackApp(pool2, "rackapp.tmp");
+		session1.reset();
+		session2.reset();
+		EVENTUALLY(5,
+			result = pool->getCount() == 2u;
+		);
+		
+		touchFile("rackapp.tmp/tmp/restart.txt");
+		spawnRackApp(pool, "rackapp.tmp");
+		
+		ensure_equals("No apps are active", pool->getActive(), 0u);
+		ensure_equals("Both apps are killed, and a new one was spawned",
+			pool->getCount(), 1u);
+		ensure("Restart file still exists",
+			stat("rackapp.tmp/tmp/restart.txt", &buf) == 0);
+	}
+	
+	TEST_METHOD(13) {
+		// If tmp/restart.txt was present, and its timestamp changed
+		// since the last check, then the applications under the app group name
+		// should still be restarted. However, a subsequent get()
+		// should not result in a restart.
+		pid_t old_pid;
+		TempDirCopy c("stub/rack", "rackapp.tmp");
+		TempDir d("rackapp.tmp/tmp/restart.txt");
+		SessionPtr session = spawnRackApp(pool, "rackapp.tmp");
+		old_pid = session->getPid();
+		session.reset();
+		EVENTUALLY(5,
+			result = pool->getActive() == 0u;
+		);
+		
+		touchFile("rackapp.tmp/tmp/restart.txt", 10);
+		
+		session = spawnRackApp(pool, "rackapp.tmp");
+		ensure("The app was restarted", session->getPid() != old_pid);
+		old_pid = session->getPid();
+		session.reset();
+		EVENTUALLY(5,
+			result = pool->getActive() == 0u;
+		);
+		
+		session = spawnRackApp(pool, "rackapp.tmp");
+		ensure_equals("The app was not restarted",
+			old_pid, session->getPid());
+	}
+	
+	TEST_METHOD(15) {
+		// Test whether restarting with restart.txt really results in code reload.
+		TempDirCopy c("stub/rack", "rackapp.tmp");
+		SessionPtr session = spawnRackApp(pool, "rackapp.tmp");
+		sendTestRequest(session);
+		string result = readAll(session->getStream());
+		ensure(result.find("hello <b>world</b>") != string::npos);
+		session.reset();
+		EVENTUALLY(5,
+			result = pool->getActive() == 0u;
+		);
+		
+		touchFile("rackapp.tmp/tmp/restart.txt");
+		replaceStringInFile("rackapp.tmp/config.ru", "world", "world 2");
+		
+		session = spawnRackApp(pool, "rackapp.tmp");
+		sendTestRequest(session);
+		result = readAll(session->getStream());
+		ensure("App code has been reloaded", result.find("hello <b>world 2</b>") != string::npos);
+	}
+	
+	TEST_METHOD(16) {
+		// If tmp/always_restart.txt is present and is a file,
+		// then the application under app_root should be always restarted.
+		struct stat buf;
+		pid_t old_pid;
+		TempDirCopy c("stub/rack", "rackapp.tmp");
+		SessionPtr session1 = spawnRackApp(pool, "rackapp.tmp");
+		SessionPtr session2 = spawnRackApp(pool2, "rackapp.tmp");
+		session1.reset();
+		session2.reset();
+		EVENTUALLY(5,
+			result = pool->getActive() == 0u && pool->getCount() == 2u;
+		);
+		
+		touchFile("rackapp.tmp/tmp/always_restart.txt");
+		
+		// This get() results in a restart.
+		session1 = spawnRackApp(pool, "rackapp.tmp");
+		old_pid = session1->getPid();
+		session1.reset();
+		EVENTUALLY(5,
+			// First restart: no apps are active
+			result = pool->getActive() == 0u;
+		);
+		ensure_equals("First restart: the first 2 apps were killed, and a new one was spawned",
+			pool->getCount(), 1u);
+		ensure("always_restart file has not been deleted",
+			stat("rackapp.tmp/tmp/always_restart.txt", &buf) == 0);
+		
+		// This get() results in a restart as well.
+		session1 = spawnRackApp(pool, "rackapp.tmp");
+		ensure(old_pid != session1->getPid());
+		session1.reset();
+		EVENTUALLY(5,
+			// Second restart: no apps are active
+			result = pool->getActive() == 0u;
+		);
+		ensure_equals("Second restart: the last app was killed, and a new one was spawned",
+			pool->getCount(), 1u);
+		ensure("always_restart file has not been deleted",
+			stat("rackapp.tmp/tmp/always_restart.txt", &buf) == 0);
+	}
+	
+	TEST_METHOD(17) {
+		// If tmp/always_restart.txt is present and is a directory,
+		// then the application under app_root should be always restarted.
+		struct stat buf;
+		pid_t old_pid;
+		TempDirCopy c("stub/rack", "rackapp.tmp");
+		SessionPtr session1 = spawnRackApp(pool, "rackapp.tmp");
+		SessionPtr session2 = spawnRackApp(pool2, "rackapp.tmp");
+		session1.reset();
+		session2.reset();
+		EVENTUALLY(5,
+			result = pool->getActive() == 0u && pool->getCount() == 2u;
+		);
+		
+		TempDir d("rackapp.tmp/tmp/always_restart.txt");
+		
+		// This get() results in a restart.
+		session1 = spawnRackApp(pool, "rackapp.tmp");
+		old_pid = session1->getPid();
+		session1.reset();
+		EVENTUALLY(5,
+			// First restart: no apps are active
+			result = pool->getActive() == 0u;
+		);
+		ensure_equals("First restart: the first 2 apps were killed, and a new one was spawned",
+			pool->getCount(), 1u);
+		ensure("always_restart directory has not been deleted",
+			stat("rackapp.tmp/tmp/always_restart.txt", &buf) == 0);
+		
+		// This get() results in a restart as well.
+		session1 = spawnRackApp(pool, "rackapp.tmp");
+		ensure(old_pid != session1->getPid());
+		session1.reset();
+		EVENTUALLY(5,
+			// Second restart: no apps are active
+			result = pool->getActive() == 0u;
+		);
+		ensure_equals("Second restart: the last app was killed, and a new one was spawned",
+			pool->getCount(), 1u);
+		ensure("always_restart directory has not been deleted",
+			stat("rackapp.tmp/tmp/always_restart.txt", &buf) == 0);
+	}
+	
+	TEST_METHOD(18) {
+		// Test whether restarting with tmp/always_restart.txt really results in code reload.
+		TempDirCopy c("stub/rack", "rackapp.tmp");
+		SessionPtr session = spawnRackApp(pool, "rackapp.tmp");
+		sendTestRequest(session);
+		string result = readAll(session->getStream());
+		ensure(result.find("hello <b>world</b>") != string::npos);
+		session.reset();
+
+		touchFile("rackapp.tmp/tmp/always_restart.txt");
+		replaceStringInFile("rackapp.tmp/config.ru", "world", "world 2");
+		
+		session = spawnRackApp(pool, "rackapp.tmp");
+		sendTestRequest(session);
+		result = readAll(session->getStream());
+		ensure("App code has been reloaded (1)", result.find("hello <b>world 2</b>") != string::npos);
+		session.reset();
+		EVENTUALLY(5,
+			result = pool->getActive() == 0u;
+		);
+		
+		replaceStringInFile("rackapp.tmp/config.ru", "world 2", "world 3");
+		session = spawnRackApp(pool, "rackapp.tmp");
+		sendTestRequest(session);
+		result = readAll(session->getStream());
+		ensure("App code has been reloaded (2)", result.find("hello <b>world 3</b>") != string::npos);
+		session.reset();
+	}
+	
+	TEST_METHOD(19) {
+		// If tmp/restart.txt and tmp/always_restart.txt are present, 
+		// the application under app_root should still be restarted and
+		// both files must be kept.
+		pid_t old_pid, pid;
+		struct stat buf;
+		TempDirCopy c("stub/rack", "rackapp.tmp");
+		SessionPtr session1 = spawnRackApp(pool, "rackapp.tmp");
+		SessionPtr session2 = spawnRackApp(pool2, "rackapp.tmp");
+		session1.reset();
+		session2.reset();
+		EVENTUALLY(5,
+			result = pool->getActive() == 0u && pool->getCount() == 2u;
+		);
+		
+		touchFile("rackapp.tmp/tmp/restart.txt");
+		touchFile("rackapp.tmp/tmp/always_restart.txt");
+		
+		old_pid = spawnRackApp(pool, "rackapp.tmp")->getPid();
+		ensure("always_restart.txt file has not been deleted",
+			stat("rackapp.tmp/tmp/always_restart.txt", &buf) == 0);
+		ensure("restart.txt file has not been deleted",
+			stat("rackapp.tmp/tmp/restart.txt", &buf) == 0);
+		EVENTUALLY(5,
+			result = pool->getActive() == 0u;
+		);
+		
+		pid = spawnRackApp(pool, "rackapp.tmp")->getPid();
+		ensure("The app was restarted", pid != old_pid);
+	}
+	
+	TEST_METHOD(20) {
+		// It should look for restart.txt in the directory given by
+		// the restartDir option, if available.
+		struct stat buf;
+		char path[1024];
+		PoolOptions options("stub/rack");
+		options.appType = "rack";
+		options.restartDir = string(getcwd(path, sizeof(path))) + "/stub/rack";
+		
+		SessionPtr session1 = pool->get(options);
+		SessionPtr session2 = pool2->get(options);
+		session1.reset();
+		session2.reset();
+		EVENTUALLY(5,
+			result = pool->getActive() == 0u && pool->getCount() == 2u;
+		);
+		
+		DeleteFileEventually f("stub/rack/restart.txt");
+		touchFile("stub/rack/restart.txt");
+		
+		pool->get(options);
+		
+		ensure_equals("No apps are active", pool->getActive(), 0u);
+		ensure_equals("Both apps are killed, and a new one was spawned",
+			pool->getCount(), 1u);
+		ensure("Restart file still exists",
+			stat("stub/rack/restart.txt", &buf) == 0);
+	}
+	
+	TEST_METHOD(21) {
+		// restartDir may also be a directory relative to the
+		// application root.
+		struct stat buf;
+		PoolOptions options("stub/rack");
+		options.appType = "rack";
+		options.restartDir = "public";
+		
+		SessionPtr session1 = pool->get(options);
+		SessionPtr session2 = pool2->get(options);
+		session1.reset();
+		session2.reset();
+		EVENTUALLY(5,
+			result = pool->getActive() == 0u && pool->getCount() == 2u;
+		);
+		
+		DeleteFileEventually f("stub/rack/public/restart.txt");
+		touchFile("stub/rack/public/restart.txt");
+		
+		pool->get(options);
+		
+		ensure_equals("No apps are active", pool->getActive(), 0u);
+		ensure_equals("Both apps are killed, and a new one was spawned",
+			pool->getCount(), 1u);
+		ensure("Restart file still exists",
+			stat("stub/rack/public/restart.txt", &buf) == 0);
+	}
+	
+	TEST_METHOD(22) {
+		// The cleaner thread should clean idle applications.
+		pool->setMaxIdleTime(1);
+		spawnRackApp(pool, "stub/rack");
+		EVENTUALLY(10,
+			result = pool->getCount() == 0u;
+		);
+		
+		time_t begin = time(NULL);
+		while (pool->getCount() == 1u && time(NULL) - begin < 10) {
+			usleep(100000);
+		}
+		ensure_equals("App should have been cleaned up", pool->getCount(), 0u);
+	}
+	
+	TEST_METHOD(23) {
+		// MaxPerApp is respected.
+		pool->setMax(3);
+		pool->setMaxPerApp(1);
+		
+		// We connect to stub/rack while it already has an instance with
+		// 1 request in its queue. Assert that the pool doesn't spawn
+		// another instance.
+		SessionPtr session1 = spawnRackApp(pool, "stub/rack");
+		SessionPtr session2 = spawnRackApp(pool2, "stub/rack");
+		
+		// We connect to stub/wsgi. Assert that the pool spawns a new
+		// instance for this app.
+		TempDirCopy c("stub/wsgi", "wsgiapp.tmp");
+		ApplicationPool::Ptr pool3 = newPoolConnection();
+		SessionPtr session3 = spawnWsgiApp(pool3, "wsgiapp.tmp");
+		ensure_equals(pool->getCount(), 2u);
+	}
+	
+	TEST_METHOD(24) {
+		// Application instance is shutdown after 'maxRequests' requests.
+		PoolOptions options("stub/rack");
+		int reader;
+		pid_t originalPid;
+		SessionPtr session;
+		
+		options.appType = "rack";
+		options.maxRequests = 4;
+		pool->setMax(1);
+		session = pool->get(options);
+		originalPid = session->getPid();
+		session.reset();
+		EVENTUALLY(5,
+			result = pool->getActive() == 0u;
+		);
+		
+		for (unsigned int i = 0; i < 4; i++) {
+			session = pool->get(options);
+			sendTestRequest(session);
+			session->shutdownWriter();
+			reader = session->getStream();
+			readAll(reader);
+			// Must explicitly call reset() here because we
+			// want to close the session right now.
+			session.reset();
+			EVENTUALLY(5,
+				result = pool->getActive() == 0u;
+			);
+		}
+		
+		session = pool->get(options);
+		ensure(session->getPid() != originalPid);
+	}
+	
+	TEST_METHOD(25) {
+		// If global queueing mode is enabled, then get() waits until
+		// there's at least one idle backend process for this application
+		// domain.
+		pool->setMax(1);
+		
+		PoolOptions options;
+		options.appRoot = "stub/rack";
+		options.appType = "rack";
+		options.useGlobalQueue = true;
+		SessionPtr session = pool->get(options);
+		
+		bool done = false;
+		SpawnRackAppFunction func;
+		func.pool = pool2;
+		func.done = &done;
+		TempThread thr(func);
+		
+		// Previous session hasn't been closed yet, so pool should still
+		// be waiting.
+		usleep(100000);
+		ensure("(1)", !done);
+		ensure_equals("(2)", pool->getGlobalQueueSize(), 1u);
+		ensure_equals("(3)", pool->getActive(), 1u);
+		ensure_equals("(4)", pool->getCount(), 1u);
+		
+		// Close the previous session. The thread should now finish.
+		session.reset();
+		EVENTUALLY(5,
+			result = done;
+		);
+	}
+	
+	TEST_METHOD(26) {
+		// When a previous application group spinned down, and we touched
+		// restart.txt and try to spin up a new process for this domain,
+		// then any ApplicationSpawner/FrameworkSpawner processes should be
+		// killed first.
+		SessionPtr session;
+		TempDirCopy c1("stub/rack", "rackapp1.tmp");
+		TempDirCopy c2("stub/rack", "rackapp2.tmp");
+		shared_ptr<ReloadLoggingSpawnManager> spawnManager(
+			new ReloadLoggingSpawnManager("../helper-scripts/passenger-spawn-server", generation)
+		);
+		reinitializeWithSpawnManager(spawnManager);
+		
+		pool->setMax(1);
+		session = spawnRackApp(pool, "rackapp1.tmp");
+		session.reset();
+		session = spawnRackApp(pool, "rackapp2.tmp");
+		ensure_equals("rackapp2.tmp is not reloaded because restart.txt is not touched",
+			spawnManager->reloadLog.size(), 0u);
+		session.reset();
+		EVENTUALLY(5,
+			result = pool->getActive() == 0u;
+		);
+		
+		touchFile("rackapp1.tmp/tmp/restart.txt");
+		session = spawnRackApp(pool, "rackapp1.tmp");
+		ensure_equals("rackapp1.tmp is reloaded because restart.txt is touched (1)",
+			spawnManager->reloadLog.size(), 1u);
+		ensure_equals("rackapp1.tmp is reloaded because restart.txt is touched (2)",
+			spawnManager->reloadLog[0], "rackapp1.tmp");
+	}
+	
+	TEST_METHOD(27) {
+		// Test inspect()
+		SessionPtr session1 = spawnRackApp(pool, "stub/rack");
+		string str = pool->inspect();
+		ensure("Contains 'max = '", str.find("max ") != string::npos);
+		ensure("Contains PID", str.find("PID: " + toString(session1->getPid())) != string::npos);
+	}
+	
+	TEST_METHOD(28) {
+		// Test toXml(true)
+		SessionPtr session1 = spawnRackApp(pool, "stub/rack");
+		string xml = pool->toXml();
+		ensure("Contains <process>", xml.find("<process>") != string::npos);
+		ensure("Contains PID", xml.find("<pid>" + toString(session1->getPid()) + "</pid>") != string::npos);
+		ensure("Contains sensitive information", xml.find("<server_sockets>") != string::npos);
+	}
+	
+	TEST_METHOD(29) {
+		// Test toXml(false)
+		SessionPtr session1 = spawnRackApp(pool, "stub/rack");
+		string xml = pool->toXml(false);
+		ensure("Contains <process>", xml.find("<process>") != string::npos);
+		ensure("Contains PID", xml.find("<pid>" + toString(session1->getPid()) + "</pid>") != string::npos);
+		ensure("Does not contain sensitive information", xml.find("<server_sockets>") == string::npos);
+	}
+	
+	TEST_METHOD(30) {
+		// Test detach().
+		
+		// Create 2 processes, where only the first one is active.
+		SessionPtr session1 = spawnRackApp(pool, "stub/rack");
+		SessionPtr session2 = spawnRackApp(pool2, "stub/rack");
+		session2.reset();
+		EVENTUALLY(5,
+			result = pool->getActive() == 1u && pool->getCount() == 2u;
+		);
+		
+		// Make sure session2 refers to a different process than session1.
+		session2 = spawnRackApp(pool2, "stub/rack");
+		string session2dk = session2->getDetachKey();
+		session2.reset();
+		EVENTUALLY(5,
+			result = pool->getActive() == 1u;
+		);
+		
+		// First detach works. It was active so the 'active' property
+		// is decremented.
+		ensure("(10)", pool->detach(session1->getDetachKey()));
+		ensure_equals("(11)", pool->getActive(), 0u);
+		ensure_equals("(12)", pool->getCount(), 1u);
+		
+		// Second detach with the same identifier doesn't do anything.
+		ensure("(20)", !pool->detach(session1->getDetachKey()));
+		ensure_equals("(21)", pool->getActive(), 0u);
+		ensure_equals("(22)", pool->getCount(), 1u);
+		
+		// Detaching an inactive process works too.
+		ensure("(30)", pool->detach(session2dk));
+		ensure_equals("(31)", pool->getActive(), 0u);
+		ensure_equals("(32)", pool->getCount(), 0u);
+	}
+	
+	TEST_METHOD(31) {
+		// If the app group does not yet exist, and options.minProcesses > 0,
+		// then get() will spawn 1 process immediately, return its session,
+		// and spawn more processes in the background until options.minProcesses
+		// is satisfied.
+		TempDirCopy c1("stub/rack", "rackapp.tmp");
+		PoolOptions options;
+		options.appRoot = "rackapp.tmp";
+		options.appType = "rack";
+		options.minProcesses = 3;
+		options.spawnMethod = "conservative";
+		
+		writeFile("rackapp.tmp/config.ru",
+			"sleep 0.1\n"
+			"run lambda {}\n");
+		
+		SessionPtr session1 = pool->get(options);
+		ensure_equals(pool->getActive(), 1u);
+		ensure_equals(pool->getCount(), 1u);
+		
+		EVENTUALLY(5,
+			result = pool->getCount() == 3u;
+		);
+	}
+	
+	TEST_METHOD(32) {
+		// If the app group already exists, all processes are active,
+		// count < max, options.minProcesses > 0 and global queuing turned off,
+		// then get() will check out an existing process immediately
+		// and spawn new ones in the background until options.minProcesses
+		// is satisfied.
+		TempDirCopy c1("stub/rack", "rackapp.tmp");
+		PoolOptions options;
+		options.appRoot = "rackapp.tmp";
+		options.appType = "rack";
+		options.spawnMethod = "conservative";
+		options.minProcesses = 3;
+		pool->setMax(3);
+		
+		// Spawn a single process.
+		SessionPtr session1 = pool->get(options);
+		ensure_equals(pool->getActive(), 1u);
+		ensure_equals(pool->getCount(), 1u);
+		
+		writeFile("rackapp.tmp/config.ru",
+			"sleep 0.1\n"
+			"run lambda {}\n");
+		
+		// Now call get(); this one will use the previous process
+		// and spawn a new one in the background.
+		SessionPtr session2 = pool2->get(options);
+		ensure_equals(pool->getActive(), 1u);
+		ensure_equals(pool->getCount(), 1u);
+		ensure_equals(session1->getPid(), session2->getPid());
+		
+		EVENTUALLY(5,
+			result = pool->getCount() == 3u;
+		);
+	}
+	
+	/* If the app group already exists, all processes are active,
+	 * count < max, options.minProcesses > 0 and global queuing turned on,
+	 * then get() will wait until either
+	 * (1) an existing process becomes inactive.
+	 * or until
+	 * (2) a new process has been spawned.
+	 */
+	
+	TEST_METHOD(33) {
+		// Here we test scenario (1).
+		PoolOptions options;
+		options.appRoot = "stub/rack";
+		options.appType = "rack";
+		options.minProcesses = 3;
+		options.useGlobalQueue = true;
+		pool->setMax(3);
+		
+		ApplicationPool::Ptr pool3 = newPoolConnection();
+		ApplicationPool::Ptr pool4 = newPoolConnection();
+		
+		// Spawn 3 processes.
+		SessionPtr session1 = pool->get(options);
+		SessionPtr session2 = pool2->get(options);
+		session2.reset();
+		EVENTUALLY(5,
+			result = pool->getCount() == 3u;
+		);
+		
+		// Make sure all of them are active.
+		session2 = pool2->get(options);
+		SessionPtr session3 = pool3->get(options);
+		ensure_equals(pool->getActive(), 3u);
+		ensure_equals(pool->getCount(), 3u);
+		
+		// Now call get() in a thread.
+		SpawnRackAppFunction func;
+		bool done = false;
+		func.pool = pool4;
+		func.done = &done;
+		TempThread thr(func);
+		
+		usleep(20000);
+		ensure("Still waiting on global queue", !done);
+		ensure_equals(pool->getGlobalQueueSize(), 1u);
+		
+		// Make 1 process available.
+		session1.reset();
+		EVENTUALLY(5,
+			result = done;
+		);
+	}
+	
+	TEST_METHOD(34) {
+		// Here we test scenario (2).
+		PoolOptions options;
+		options.appRoot = "stub/rack";
+		options.appType = "rack";
+		options.minProcesses = 3;
+		options.useGlobalQueue = true;
+		pool->setMax(3);
+		
+		ApplicationPool::Ptr pool3 = newPoolConnection();
+		ApplicationPool::Ptr pool4 = newPoolConnection();
+		ApplicationPool::Ptr pool5 = newPoolConnection();
+		
+		// Spawn 3 processes.
+		SessionPtr session1 = pool->get(options);
+		SessionPtr session2 = pool2->get(options);
+		session2.reset();
+		EVENTUALLY(5,
+			result = pool->getCount() == 3u;
+		);
+		
+		// Make sure all of them are active.
+		session2 = pool2->get(options);
+		SessionPtr session3 = pool3->get(options);
+		ensure_equals(pool->getActive(), 3u);
+		ensure_equals(pool->getCount(), 3u);
+		
+		// Now call get() in a thread.
+		SpawnRackAppFunction func1;
+		SessionPtr session4;
+		bool done1 = false;
+		func1.pool = pool4;
+		func1.done = &done1;
+		func1.session = &session4;
+		TempThread thr1(func1);
+		
+		// And again.
+		SpawnRackAppFunction func2;
+		SessionPtr session5;
+		bool done2 = false;
+		func2.pool = pool5;
+		func2.done = &done2;
+		func2.session = &session5;
+		TempThread thr2(func2);
+		
+		// We should now arrive at a state where there are 3 processes, all
+		// busy, and 2 threads waiting on the global queue.
+		usleep(20000);
+		ensure("Still waiting on global queue", !done1 && !done2);
+		ensure_equals(pool->getGlobalQueueSize(), 2u);
+		
+		// Increasing the max will cause one of the threads to wake
+		// up, start a spawn action in the background, and go to sleep
+		// again. Eventually the new process will be done spawning,
+		// causing one of the threads to wake up. The other one will
+		// continue to wait.
+		pool->setMax(4);
+		EVENTUALLY(5,
+			result = (done1 && !done2) || (!done1 && done2);
+		);
+	}
+	
+	TEST_METHOD(35) {
+		// When spawning an app in the background, if it encountered an error
+		// it will remove the whole app group.
+		TempDirCopy c1("stub/rack", "rackapp.tmp");
+		PoolOptions options;
+		options.appRoot = "rackapp.tmp";
+		options.appType = "rack";
+		options.spawnMethod = "conservative";
+		options.printExceptions = false;
+		
+		SessionPtr session1 = pool->get(options);
+		
+		writeFile("rackapp.tmp/config.ru",
+			"raise 'foo'\n");
+		pool2->get(options);
+		
+		EVENTUALLY(5,
+			result = pool->getCount() == 0u;
+		);
+	}
+	
+	TEST_METHOD(36) {
+		// When cleaning, at least options.minProcesses processes should be kept around.
+		pool->setMaxIdleTime(0);
+		ApplicationPool::Ptr pool3 = newPoolConnection();
+		PoolOptions options;
+		options.appRoot = "stub/rack";
+		options.appType = "rack";
+		options.minProcesses = 2;
+		
+		// Spawn 2 processes.
+		SessionPtr session1 = pool->get(options);
+		SessionPtr session2 = pool2->get(options);
+		session1.reset();
+		session2.reset();
+		EVENTUALLY(5,
+			result = pool->getActive() == 0u && pool->getCount() == 2u;
+		);
+		
+		// Spawn another process, so we get 3.
+		session1 = pool->get(options);
+		session2 = pool2->get(options);
+		SessionPtr session3 = pool3->get(options);
+		session3.reset();
+		EVENTUALLY(5,
+			result = pool->getActive() == 2u && pool->getCount() == 3u;
+		);
+		
+		// Now wait until one process is idle cleaned.
+		pool->setMaxIdleTime(1);
+		EVENTUALLY(10,
+			result = pool->getCount() == 2u;
+		);
+	}
+	
+	TEST_METHOD(37) {
+		// Test whether processes are grouped together by appGroupName.
+		TempDirCopy c1("stub/rack", "rackapp.tmp");
+		PoolOptions options1;
+		options1.appRoot = "rackapp.tmp";
+		options1.appType = "rack";
+		options1.appGroupName = "group A";
+		SessionPtr session1 = pool->get(options1);
+		
+		TempDirCopy c2("stub/rack", "rackapp2.tmp");
+		PoolOptions options2;
+		options2.appRoot = "rackapp2.tmp";
+		options2.appType = "rack";
+		options2.appGroupName = "group A";
+		SessionPtr session2 = pool2->get(options2);
+		
+		session1.reset();
+		session2.reset();
+		EVENTUALLY(5,
+			result = pool->getCount() == 2u;
+		);
+		
+		touchFile("rackapp.tmp/tmp/restart.txt");
+		session1 = pool->get(options1);
+		ensure_equals(pool->getCount(), 1u);
+	}
+	
+	/*************************************/
+	
+#endif /* USE_TEMPLATE */