RubyGems - passenger - Versions diffs - 3.0.21 → 3.9.1.beta - Mend

@@ -52,6 +52,12 @@ dd {
 	font-family: 'Bitstream Vera Sans Mono', 'Courier New', Monospace;
 }
+pre {
+	overflow: auto;
+	white-space: pre-wrap;
+	text-align: left;
+}
 table.backtrace th {
 	background: #8470a6;
 	color: white;

data/resources/templates/error_layout.html.template ADDED

@@ -0,0 +1,89 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
+<html>
+<head>
+	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+	<meta name="generator" content="Phusion Passenger">
+	<title>{{TITLE}}</title>
+	<style type="text/css">
+		{{CSS|raw}}
+	</style>
+	<link rel="stylesheet" type="text/css" href="http://www.modrails.com/error_pages/1.0/error_page.css">
+	<style type="text/css">
+		dd {
+			text-align: left;
+		}
+		dd pre {
+			margin-top: 0;
+			margin-bottom: 0;
+		}
+	</style>
+</head>
+<body>
+	<div id="site_container">
+		<div id="site_header">
+			<ul class="corporate_identity">
+				<li class="logo"><a href="https://www.phusionpassenger.com"><span>Phusion Passenger</span></a></li>
+			</ul>
+		</div>
+		<div id="site_body">
+			<h1 class="error_title">{{TITLE}}</h1>
+			<div id="content">
+				{{CONTENT|raw}}
+				<dl>
+				<dt>Application root</dt>
+				<dd>{{APP_ROOT}}</dd>
+				<dt>Environment (value of RAILS_ENV, RACK_ENV, WSGI_ENV and PASSENGER_ENV)</dt>
+				<dd>{{ENVIRONMENT}}</dd>
+				{{if IS_RUBY_APP}}
+					<dt>Ruby interpreter command</dt>
+					<dd><pre>{{RUBY}}</pre></dd>
+				{{/if}}
+				<dt>User and groups</dt>
+				<dd><pre>{{USER_INFO|default=Unknown}}</pre></dd>
+				<dt>Environment variables</dt>
+				<dd><pre>{{ENVVARS|default=Unknown}}</pre></dd>
+				<dt>Ulimits</dt>
+				<dd><pre>{{ULIMIT|default=Unknown}}</pre></dd>
+				{{if RUBY_INFO}}
+					<dt>General Ruby interpreter information</dt>
+					<dd><pre>{{RUBY_INFO}}</pre></dd>
+				{{/if}}
+				{{if RBCONFIG}}
+					<dt>Ruby configuration (RbConfig::CONFIG)</dt>
+					<dd><pre>{{RBCONFIG}}</pre></dd>
+				{{/if}}
+				{{if ACTIVATED_GEMS}}
+					<dt>Activated Ruby gems</dt>
+					<dd><pre>{{ACTIVATED_GEMS}}</pre></dd>
+				{{/if}}
+				{{if LOAD_PATH}}
+					<dt>Ruby load path ($LOAD_PATH)</dt>
+					<dd><pre>{{LOAD_PATH}}</pre></dd>
+				{{/if}}
+				{{if LOADED_LIBS}}
+					<dt>Ruby loaded libraries ($LOADED_FEATURES)</dt>
+					<dd><pre>{{LOADED_LIBS}}</pre></dd>
+				{{/if}}
+				</dl>
+			</div>
+		</div>
+		<div id="site_footer">
+			<!--
+			   You are free to modify the footer as you see fit,
+			   but we kindly ask of you to preserve to following
+			   text. Thank you.
+			-->
+			<div class="container">
+				Powered by <a href="https://www.phusionpassenger.com/">Phusion Passenger</a>,
+				<tt>mod_rails</tt> / <tt>mod_rack</tt> for Apache and Nginx.
+			</div>
+		</div>
+	</div>
+</body>
+</html>

data/resources/templates/general_error.html.template ADDED

	@@ -0,0 +1 @@
1	+ <pre>{{MESSAGE}}</pre>

data/resources/templates/general_error_with_html.html.template ADDED

	@@ -0,0 +1 @@
1	+ {{MESSAGE}}

data/{lib/phusion_passenger → resources}/templates/nginx/ask_for_extra_configure_flags.txt.erb RENAMED

File without changes

data/{lib/phusion_passenger → resources}/templates/nginx/cannot_write_to_dir.txt.erb RENAMED

File without changes

data/{lib/phusion_passenger → resources}/templates/nginx/config_snippets.txt.erb RENAMED

File without changes

data/{lib/phusion_passenger → resources}/templates/nginx/config_snippets_inserted.txt.erb RENAMED

File without changes

data/{lib/phusion_passenger → resources}/templates/nginx/confirm_extra_configure_flags.txt.erb RENAMED

File without changes

data/{lib/phusion_passenger → resources}/templates/nginx/deployment_example.txt.erb RENAMED

File without changes

data/resources/templates/nginx/not_available_when_natively_packaged.txt.erb ADDED

@@ -0,0 +1,8 @@
+<red>passenger-install-nginx-module is not available when packaged</red>
+This Phusion Passenger installation is provided by your packager (as opposed to being installed from source). As such, you cannot use passenger-install-nginx-module. If you want to use passenger-install-nginx-module, please install Phusion Passenger from source by downloading it from <b>www.modrails.com</b>.
+For more information about using Phusion Passenger for Nginx, please consult the documentation at one of the following places:
+ * <b><%= PhusionPassenger.doc_dir %>/Users Guide Nginx.html</b>
+ * <b>http://www.modrails.com/documentation.html</b>

data/{lib/phusion_passenger → resources}/templates/nginx/pcre_could_not_be_downloaded.txt.erb RENAMED

File without changes

data/{lib/phusion_passenger → resources}/templates/nginx/pcre_could_not_be_extracted.txt.erb RENAMED

File without changes

data/{lib/phusion_passenger → resources}/templates/nginx/possible_solutions_for_compilation_and_installation_problems.txt.erb RENAMED

File without changes

data/{lib/phusion_passenger → resources}/templates/nginx/possible_solutions_for_download_and_extraction_problems.txt.erb RENAMED

File without changes

data/{lib/phusion_passenger → resources}/templates/nginx/query_download_and_install.txt.erb RENAMED

File without changes

data/{lib/phusion_passenger → resources}/templates/nginx/run_installer_as_root.txt.erb RENAMED

File without changes

data/{lib/phusion_passenger → resources}/templates/nginx/welcome.txt.erb RENAMED

File without changes

data/{lib/phusion_passenger → resources}/templates/standalone/cannot_write_to_dir.txt.erb RENAMED

File without changes

data/{lib/phusion_passenger → resources}/templates/standalone/config.erb RENAMED

@@ -37,9 +37,9 @@ events {
 http {
     log_format debug '[$time_local] $msec  "$request" $status conn=$connection sent=$bytes_sent body_sent=$body_bytes_sent';
-    include '<%= PhusionPassenger::RESOURCES_DIR %>/mime.types';
+    include '<%= PhusionPassenger.resources_dir %>/mime.types';
     passenger_ruby <%= PlatformInfo.ruby_command %>;
-    passenger_root '<%= passenger_root %>';
+    passenger_root '<%= @location_config_filename %>';
     passenger_abort_on_startup_error on;
     passenger_user_switching off;
     passenger_max_pool_size <%= @options[:max_pool_size] %>;
@@ -47,7 +47,6 @@ http {
     <% if @options[:user] %>passenger_default_user <%= @options[:user] %>;<% end %>
     <% if debugging? %>passenger_log_level 2;<% end %>
     <% if @options[:rolling_restarts] %>passenger_rolling_restarts on;<% end %>
-    <% if @options[:resist_deployment_errors] %>passenger_resist_deployment_errors on;<% end %>
     <% if @options[:union_station_gateway_address] %>
         union_station_gateway_address <%= @options[:union_station_gateway_address] %>;
@@ -69,14 +68,14 @@ http {
     # Default server entry.
     server {
         listen <%= nginx_listen_address %>;
-        root '<%= LIBDIR %>/phusion_passenger/templates/standalone_default_root';
+        root '<%= PhusionPassenger.resources_dir %>/standalone_default_root';
     }
     <% end %>
     <% if @options[:ping_port] %>
     server {
         listen <%= nginx_listen_address(@options, true) %>;
-        root '<%= LIBDIR %>/phusion_passenger/templates/standalone_default_root';
+        root '<%= PhusionPassenger.resources_dir %>/standalone_default_root';
     }
     <% end %>
@@ -93,6 +92,28 @@ http {
             union_station_support on;
             union_station_key <%= app[:union_station_key] %>;
         <% end %>
+        location ~ ^/assets/ {
+            error_page 490 = @static_asset;
+            error_page 491 = @dynamic_request;
+            recursive_error_pages on;
+            if (-f $request_filename) {
+                return 490;
+            }
+            if (!-f $request_filename) {
+                return 491;
+            }
+        }
+        location @static_asset {
+            gzip_static on;
+            expires max;
+            add_header Cache-Control public;
+            add_header ETag "";
+        }
+        location @dynamic_request {
+            passenger_enabled on;
+        }
     }
     passenger_pre_start http://<%= nginx_listen_address(app) %>;
     <% end %>

data/{lib/phusion_passenger → resources}/templates/standalone/possible_solutions_for_download_and_extraction_problems.txt.erb RENAMED

File without changes

data/{lib/phusion_passenger → resources}/templates/standalone/run_installer_as_root.txt.erb RENAMED

File without changes

data/{lib/phusion_passenger → resources}/templates/standalone/welcome.txt.erb RENAMED

File without changes

data/resources/templates/undisclosed_error.html.template ADDED

@@ -0,0 +1,25 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>We're sorry, but something went wrong (500)</title>
+  <style type="text/css">
+    body { background-color: #fff; color: #666; text-align: center; font-family: arial, sans-serif; }
+    div.dialog {
+      width: 25em;
+      padding: 0 4em;
+      margin: 4em auto 0 auto;
+      border: 1px solid #ccc;
+      border-right-color: #999;
+      border-bottom-color: #999;
+    }
+    h1 { font-size: 100%; color: #f00; line-height: 1.5em; }
+  </style>
+</head>
+<body>
+  <div class="dialog">
+    <h1>We're sorry, but something went wrong.</h1>
+    <p>We've been notified about this issue and we'll take a look at it shortly.</p>
+  </div>
+</body>
+</html>

data/test/config.json.example ADDED

@@ -0,0 +1,42 @@
+{
+  //// This file contains system-specific configuration options that the test suite needs.
+  //// Please customize it for your system.
+  // 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.
+  //
+  // These users and groups MUST be able to access this 'test' directory,
+  // otherwise the tests will fail.
+  //// Good values for OS X:
+  "normal_user_1": "_www",
+  "normal_user_2": "daemon",
+  // Must not be "nobody".
+  "default_user": "_sandbox",
+  // 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": "_sandbox",
+  // Must not be default_user's primary group. Must not be "nobody".
+  "default_group": "_www",
+  ///// Good values for Linux and FreeBSD. Same restrictions apply.
+  //"normal_user_1": "games",
+  //"normal_user_2": "daemon",
+  //"default_user": "man",
+  //"normal_group_1": "daemon",
+  //"normal_group_2": "man",
+  //"default_group": "games",
+  // A nonexistant username, group name, user ID and group ID.
+  "nonexistant_user": "xxxxxxxxxxxxxxxxxxx",
+  "nonexistant_group": "xxxxxxxxxxxxxxxxxxx",
+  "nonexistant_uid": 9999,
+  "nonexistant_gid": 9999,
+  // If you want to run the Nginx integration tests, then set the following
+  // config option to the full path of the Nginx binary. This Nginx binary *must*
+  // be compiled with Phusion Passenger support!
+  // nginx: /usr/local/sbin/nginx
+}

data/test/cxx/ApplicationPool2/DirectSpawnerTest.cpp ADDED

@@ -0,0 +1,86 @@
+#include <TestSupport.h>
+#include <ApplicationPool2/Spawner.h>
+#include <Utils/json.h>
+using namespace Passenger;
+using namespace Passenger::ApplicationPool2;
+namespace tut {
+	struct ApplicationPool2_DirectSpawnerTest {
+		ServerInstanceDirPtr serverInstanceDir;
+		ServerInstanceDir::GenerationPtr generation;
+		BackgroundEventLoop bg;
+		ApplicationPool2_DirectSpawnerTest() {
+			createServerInstanceDirAndGeneration(serverInstanceDir, generation);
+			bg.start();
+		}
+		~ApplicationPool2_DirectSpawnerTest() {
+			unlink("stub/wsgi/passenger_wsgi.pyc");
+		}
+		shared_ptr<DirectSpawner> createSpawner(const Options &options) {
+			return make_shared<DirectSpawner>(bg.safe,
+				*resourceLocator, generation);
+		}
+		Options createOptions() {
+			Options options;
+			options.spawnMethod = "direct";
+			options.loadShellEnvvars = false;
+			return options;
+		}
+	};
+	DEFINE_TEST_GROUP_WITH_LIMIT(ApplicationPool2_DirectSpawnerTest, 90);
+	#include "SpawnerTestCases.cpp"
+	TEST_METHOD(80) {
+		// If the application didn't start within the timeout
+		// then whatever was written to stderr is used as the
+		// SpawnException error page.
+		Options options = createOptions();
+		options.appRoot      = "stub";
+		options.startCommand = "perl\1" "-e\1" "print STDERR \"hello world\\n\"; sleep(60)";
+		options.startupFile  = ".";
+		options.startTimeout = 300;
+		DirectSpawner spawner(bg.safe, *resourceLocator, generation);
+		spawner.forwardStderr = false;
+		try {
+			spawner.spawn(options);
+			fail("Timeout expected");
+		} catch (const SpawnException &e) {
+			ensure_equals(e.getErrorKind(),
+				SpawnException::APP_STARTUP_TIMEOUT);
+			ensure_equals(e.getErrorPage(),
+				"hello world\n");
+		}
+	}
+	TEST_METHOD(81) {
+		// If the application crashed during startup without returning
+		// a proper error response, then its stderr output is used
+		// as error response instead.
+		Options options = createOptions();
+		options.appRoot      = "stub";
+		options.startCommand = "perl\1" "-e\1" "print STDERR \"hello world\\n\"";
+		options.startupFile  = ".";
+		DirectSpawner spawner(bg.safe, *resourceLocator, generation);
+		spawner.forwardStderr = false;
+		try {
+			spawner.spawn(options);
+			fail("SpawnException expected");
+		} catch (const SpawnException &e) {
+			ensure_equals(e.getErrorKind(),
+				SpawnException::APP_STARTUP_PROTOCOL_ERROR);
+			ensure_equals(e.getErrorPage(),
+				"hello world\n");
+		}
+	}
+}

data/test/cxx/ApplicationPool2/OptionsTest.cpp ADDED

@@ -0,0 +1,44 @@
+#include <TestSupport.h>
+#include <ApplicationPool2/Process.h>
+using namespace Passenger;
+using namespace Passenger::ApplicationPool2;
+using namespace std;
+namespace tut {
+	struct ApplicationPool2_OptionsTest {
+		ApplicationPool2_OptionsTest() {
+		}
+	};
+	DEFINE_TEST_GROUP(ApplicationPool2_OptionsTest);
+	TEST_METHOD(1) {
+		// Test persist().
+		char appRoot[] = "appRoot";
+		char processTitle[] = "processTitle";
+		char fooKey[] = "PASSENGER_FOO";
+		char fooValue[] = "foo";
+		char barKey[] = "PASSENGER_BAR";
+		char barValue[] = "bar";
+		Options options;
+		options.appRoot = appRoot;
+		options.processTitle = processTitle;
+		options.environmentVariables.push_back(make_pair(fooKey, fooValue));
+		options.environmentVariables.push_back(make_pair(barKey, barValue));
+		Options options2 = options.copyAndPersist();
+		appRoot[0] = processTitle[0] = 'x';
+		fooKey[0]  = fooValue[0]     = 'x';
+		barKey[0]  = barValue[0]     = 'x';
+		ensure_equals(options2.appRoot, "appRoot");
+		ensure_equals(options2.processTitle, "processTitle");
+		ensure_equals(options2.environmentVariables.size(), 2u);
+		ensure_equals(options2.environmentVariables[0].first, "PASSENGER_FOO");
+		ensure_equals(options2.environmentVariables[0].second, "foo");
+		ensure_equals(options2.environmentVariables[1].first, "PASSENGER_BAR");
+		ensure_equals(options2.environmentVariables[1].second, "bar");
+	}
+}

data/test/cxx/ApplicationPool2/PoolTest.cpp ADDED

@@ -0,0 +1,1234 @@
+#include <TestSupport.h>
+#include <ApplicationPool2/Pool.h>
+#include <Utils/IOUtils.h>
+#include <Utils/StrIntUtils.h>
+#include <Utils/json.h>
+#include <MessageReadersWriters.h>
+#include <map>
+#include <vector>
+#include <cerrno>
+#include <signal.h>
+using namespace std;
+using namespace Passenger;
+using namespace Passenger::ApplicationPool2;
+namespace tut {
+	struct ApplicationPool2_PoolTest {
+		ServerInstanceDirPtr serverInstanceDir;
+		ServerInstanceDir::GenerationPtr generation;
+		BackgroundEventLoop bg;
+		SpawnerFactoryPtr spawnerFactory;
+		PoolPtr pool;
+		GetCallback callback;
+		SessionPtr currentSession;
+		ExceptionPtr currentException;
+		AtomicInt number;
+		boost::mutex syncher;
+		list<SessionPtr> sessions;
+		bool retainSessions;
+		ApplicationPool2_PoolTest() {
+			createServerInstanceDirAndGeneration(serverInstanceDir, generation);
+			retainSessions = false;
+			spawnerFactory = make_shared<SpawnerFactory>(bg.safe, *resourceLocator, generation);
+			pool = make_shared<Pool>(bg.safe.get(), spawnerFactory);
+			bg.start();
+			callback = boost::bind(&ApplicationPool2_PoolTest::_callback, this, _1, _2);
+		}
+		~ApplicationPool2_PoolTest() {
+			// Explicitly destroy these here because they can run
+			// additional code that depend on other fields in this
+			// class.
+			setLogLevel(0);
+			TRACE_POINT();
+			pool->destroy();
+			UPDATE_TRACE_POINT();
+			pool.reset();
+			UPDATE_TRACE_POINT();
+			lock_guard<boost::mutex> l(syncher);
+			currentSession.reset();
+			sessions.clear();
+		}
+		Options createOptions() {
+			Options options;
+			options.spawnMethod = "dummy";
+			options.appRoot = "stub/rack";
+			options.startCommand = "ruby\1" "start.rb";
+			options.startupFile  = "start.rb";
+			options.loadShellEnvvars = false;
+			options.user = testConfig["normal_user_1"].asCString();
+			options.defaultUser = testConfig["default_user"].asCString();
+			options.defaultGroup = testConfig["default_group"].asCString();
+			return options;
+		}
+		void _callback(const SessionPtr &session, const ExceptionPtr &e) {
+			SessionPtr oldSession;
+			{
+				LockGuard l(syncher);
+				oldSession = currentSession;
+				currentSession = session;
+				currentException = e;
+				number++;
+				if (retainSessions && session != NULL) {
+					sessions.push_back(session);
+				}
+			}
+			// destroy old session object outside the lock.
+		}
+		void sendHeaders(int connection, ...) {
+			va_list ap;
+			const char *arg;
+			vector<StaticString> args;
+			va_start(ap, connection);
+			while ((arg = va_arg(ap, const char *)) != NULL) {
+				args.push_back(StaticString(arg, strlen(arg) + 1));
+			}
+			va_end(ap);
+			shared_array<StaticString> args_array(new StaticString[args.size() + 1]);
+			unsigned int totalSize = 0;
+			for (unsigned int i = 0; i < args.size(); i++) {
+				args_array[i + 1] = args[i];
+				totalSize += args[i].size();
+			}
+			char sizeHeader[sizeof(uint32_t)];
+			Uint32Message::generate(sizeHeader, totalSize);
+			args_array[0] = StaticString(sizeHeader, sizeof(uint32_t));
+			gatheredWrite(connection, args_array.get(), args.size() + 1, NULL);
+		}
+		string stripHeaders(const string &str) {
+			string::size_type pos = str.find("\r\n\r\n");
+			if (pos == string::npos) {
+				return str;
+			} else {
+				string result = str;
+				result.erase(0, pos + 4);
+				return result;
+			}
+		}
+		string sendRequest(const Options &options, const char *path) {
+			int oldNumber = number;
+			pool->asyncGet(options, callback);
+			EVENTUALLY(5,
+				result = number == oldNumber + 1;
+			);
+			if (currentException != NULL) {
+				P_ERROR("get() exception: " << currentException->what());
+				abort();
+			}
+			currentSession->initiate();
+			sendHeaders(currentSession->fd(),
+				"PATH_INFO", path,
+				"REQUEST_METHOD", "GET",
+				NULL);
+			shutdown(currentSession->fd(), SHUT_WR);
+			string body = stripHeaders(readAll(currentSession->fd()));
+			ProcessPtr process = currentSession->getProcess();
+			currentSession.reset();
+			EVENTUALLY(5,
+				result = process->utilization() == 0;
+			);
+			return body;
+		}
+	};
+	DEFINE_TEST_GROUP_WITH_LIMIT(ApplicationPool2_PoolTest, 100);
+	TEST_METHOD(1) {
+		// Test initial state.
+		ensure(!pool->atFullCapacity());
+	}
+	/*********** Test asyncGet() behavior on a single SuperGroup and Group ***********/
+	TEST_METHOD(2) {
+		// asyncGet() actions on empty pools cannot be immediately satisfied.
+		// Instead a new process will be spawned. In the mean time get()
+		// actions are put on a wait list which will be processed as soon
+		// as the new process is done spawning.
+		Options options = createOptions();
+		ScopedLock l(pool->syncher);
+		pool->asyncGet(options, callback, false);
+		ensure_equals(number, 0);
+		ensure(pool->getWaitlist.empty());
+		ensure(!pool->superGroups.empty());
+		l.unlock();
+		EVENTUALLY(5,
+			result = pool->getProcessCount() == 1;
+		);
+		ensure_equals(number, 1);
+		ensure(currentSession != NULL);
+		ensure(currentException == NULL);
+	}
+	TEST_METHOD(3) {
+		// If one matching process already exists and it's not at full
+		// capacity then asyncGet() will immediately use it.
+		Options options = createOptions();
+		// Spawn a process and opens a session with it.
+		pool->asyncGet(options, callback);
+		EVENTUALLY(5,
+			result = number == 1;
+		);
+		// Close the session so that the process is now idle.
+		ProcessPtr process = currentSession->getProcess();
+		currentSession.reset();
+		ensure_equals(process->utilization(), 0);
+		ensure(!process->atFullCapacity());
+		// Verify test assertion.
+		ScopedLock l(pool->syncher);
+		pool->asyncGet(options, callback, false);
+		ensure_equals("callback is immediately called", number, 2);
+	}
+	TEST_METHOD(4) {
+		// If one matching process already exists but it's at full capacity,
+		// and the limits prevent spawning of a new process,
+		// then asyncGet() will put the get action on the group's wait
+		// queue. When the process is no longer at full capacity it will
+		// process the request.
+		// Spawn a process and verify that it's at full capacity.
+		// Keep its session open.
+		Options options = createOptions();
+		options.appGroupName = "test";
+		pool->setMax(1);
+		pool->asyncGet(options, callback);
+		EVENTUALLY(5,
+			result = number == 1;
+		);
+		SessionPtr session1 = currentSession;
+		ProcessPtr process = session1->getProcess();
+		currentSession.reset();
+		ensure_equals(process->sessions, 1);
+		ensure(process->atFullCapacity());
+		// Now call asyncGet() again.
+		pool->asyncGet(options, callback);
+		ensure_equals("callback is not yet called", number, 1);
+		ensure_equals("the get action has been put on the wait list",
+			pool->superGroups.get("test")->defaultGroup->getWaitlist.size(), 1u);
+		session1.reset();
+		ensure_equals("callback is called after the process becomes idle",
+			number, 2);
+		ensure_equals("the get wait list has been processed",
+			pool->superGroups.get("test")->defaultGroup->getWaitlist.size(), 0u);
+		ensure_equals(process->sessions, 1);
+	}
+	TEST_METHOD(5) {
+		// If one matching process already exists but it's at full capacity,
+		// and the limits and pool capacity allow spawning of a new process,
+		// then get() will put the get action on the group's wait
+		// queue while spawning a process in the background.
+		// Either the existing process or the newly spawned process
+		// will process the action, whichever becomes first available.
+		// Here we test the case in which the existing process becomes
+		// available first.
+		// Spawn a regular process and keep its session open.
+		Options options = createOptions();
+		pool->asyncGet(options, callback);
+		EVENTUALLY(5,
+			result = number == 1;
+		);
+		SessionPtr session1 = currentSession;
+		ProcessPtr process1 = currentSession->getProcess();
+		currentSession.reset();
+		// Now spawn a process that never finishes.
+		SpawnerPtr spawner = process1->getGroup()->spawner;
+		dynamic_pointer_cast<DummySpawner>(spawner)->spawnTime = 5000000;
+		pool->asyncGet(options, callback);
+		// Release the session on the first process.
+		session1.reset();
+		ensure_equals("The callback should have been called twice now", number, 2);
+		ensure_equals("The first process handled the second asyncGet() request",
+			currentSession->getProcess(), process1);
+	}
+	TEST_METHOD(6) {
+		// Here we test the case in which the new process becomes
+		// available first.
+		// Spawn a regular process.
+		Options options = createOptions();
+		pool->asyncGet(options, callback);
+		EVENTUALLY(5,
+			result = number == 1;
+		);
+		SessionPtr session1 = currentSession;
+		ProcessPtr process1 = currentSession->getProcess();
+		currentSession.reset();
+		// As long as we don't release process1 the following get
+		// action will be processed by the newly spawned process.
+		pool->asyncGet(options, callback);
+		EVENTUALLY(5,
+			result = pool->getProcessCount() == 2;
+		);
+		ensure_equals(number, 2);
+		ensure(currentSession->getProcess() != process1);
+	}
+	TEST_METHOD(7) {
+		// If multiple matching processes exist, and one of them is idle,
+		// then asyncGet() will use that.
+		// Spawn 3 processes and keep a session open with 1 of them.
+		Options options = createOptions();
+		options.minProcesses = 3;
+		pool->asyncGet(options, callback);
+		EVENTUALLY(5,
+			result = number == 1;
+		);
+		EVENTUALLY(5,
+			result = pool->getProcessCount() == 3;
+		);
+		SessionPtr session1 = currentSession;
+		ProcessPtr process1 = currentSession->getProcess();
+		currentSession.reset();
+		// Now open another session. It should complete immediately
+		// and should not use the first process.
+		ScopedLock l(pool->syncher);
+		pool->asyncGet(options, callback, false);
+		ensure_equals("asyncGet() completed immediately", number, 2);
+		SessionPtr session2 = currentSession;
+		ProcessPtr process2 = currentSession->getProcess();
+		l.unlock();
+		currentSession.reset();
+		ensure(process2 != process1);
+		// Now open yet another session. It should also complete immediately
+		// and should not use the first or the second process.
+		l.lock();
+		pool->asyncGet(options, callback, false);
+		ensure_equals("asyncGet() completed immediately", number, 3);
+		SessionPtr session3 = currentSession;
+		ProcessPtr process3 = currentSession->getProcess();
+		l.unlock();
+		currentSession.reset();
+		ensure(process3 != process1);
+		ensure(process3 != process2);
+	}
+	TEST_METHOD(8) {
+		// If multiple matching processes exist, then asyncGet() will use
+		// the one with the smallest utilization number.
+		// Spawn 2 processes, each with a concurrency of 2.
+		Options options = createOptions();
+		options.minProcesses = 2;
+		pool->setMax(2);
+		GroupPtr group = pool->findOrCreateGroup(options);
+		dynamic_pointer_cast<DummySpawner>(group->spawner)->concurrency = 2;
+		{
+			LockGuard l(pool->syncher);
+			group->spawn();
+		}
+		EVENTUALLY(5,
+			result = pool->getProcessCount() == 2;
+		);
+		// asyncGet() selects some process.
+		pool->asyncGet(options, callback);
+		ensure_equals(number, 1);
+		SessionPtr session1 = currentSession;
+		ProcessPtr process1 = currentSession->getProcess();
+		currentSession.reset();
+		// The first process now has 1 session, so next asyncGet() should
+		// select the other process.
+		pool->asyncGet(options, callback);
+		ensure_equals(number, 2);
+		SessionPtr session2 = currentSession;
+		ProcessPtr process2 = currentSession->getProcess();
+		currentSession.reset();
+		ensure("(1)", process1 != process2);
+		// Both processes now have an equal number of sessions. Next asyncGet()
+		// can select either.
+		pool->asyncGet(options, callback);
+		ensure_equals(number, 3);
+		SessionPtr session3 = currentSession;
+		ProcessPtr process3 = currentSession->getProcess();
+		currentSession.reset();
+		// One process now has the lowest number of sessions. Next
+		// asyncGet() should select that one.
+		pool->asyncGet(options, callback);
+		ensure_equals(number, 4);
+		SessionPtr session4 = currentSession;
+		ProcessPtr process4 = currentSession->getProcess();
+		currentSession.reset();
+		ensure(process3 != process4);
+	}
+	TEST_METHOD(9) {
+		// If multiple matching processes exist, and all of them are at full capacity,
+		// and no more processes may be spawned,
+		// then asyncGet() will put the action on the group's wait queue.
+		// The process that first becomes not at full capacity will process the action.
+		// Spawn 2 processes and open 4 sessions.
+		Options options = createOptions();
+		options.appGroupName = "test";
+		options.minProcesses = 2;
+		pool->setMax(2);
+		GroupPtr group = pool->findOrCreateGroup(options);
+		dynamic_pointer_cast<DummySpawner>(group->spawner)->concurrency = 2;
+		vector<SessionPtr> sessions;
+		int expectedNumber = 1;
+		for (int i = 0; i < 4; i++) {
+			pool->asyncGet(options, callback);
+			EVENTUALLY(5,
+				result = number == expectedNumber;
+			);
+			expectedNumber++;
+			sessions.push_back(currentSession);
+			currentSession.reset();
+		}
+		EVENTUALLY(5,
+			result = pool->getProcessCount() == 2;
+		);
+		SuperGroupPtr superGroup = pool->superGroups.get("test");
+		ensure_equals(superGroup->groups[0]->getWaitlist.size(), 0u);
+		ensure(pool->atFullCapacity());
+		// Now try to open another session.
+		pool->asyncGet(options, callback);
+		ensure_equals("The get request has been put on the wait list",
+			pool->superGroups.get("test")->groups[0]->getWaitlist.size(), 1u);
+		// Close an existing session so that one process is no
+		// longer at full capacity.
+		sessions[0].reset();
+		ensure_equals("The get request has been removed from the wait list",
+			pool->superGroups.get("test")->groups[0]->getWaitlist.size(), 0u);
+		ensure(pool->atFullCapacity());
+	}
+	TEST_METHOD(10) {
+		// If multiple matching processes exist, and all of them are at full capacity,
+		// and a new process may be spawned,
+		// then asyncGet() will put the action on the group's wait queue and spawn the
+		// new process.
+		// The process that first becomes not at full capacity
+		// or the newly spawned process
+		// will process the action, whichever is earlier.
+		// Here we test the case where an existing process is earlier.
+		// Spawn 2 processes and open 4 sessions.
+		Options options = createOptions();
+		options.minProcesses = 2;
+		pool->setMax(3);
+		GroupPtr group = pool->findOrCreateGroup(options);
+		dynamic_pointer_cast<DummySpawner>(group->spawner)->concurrency = 2;
+		vector<SessionPtr> sessions;
+		int expectedNumber = 1;
+		for (int i = 0; i < 4; i++) {
+			pool->asyncGet(options, callback);
+			EVENTUALLY(5,
+				result = number == expectedNumber;
+			);
+			expectedNumber++;
+			sessions.push_back(currentSession);
+			currentSession.reset();
+		}
+		EVENTUALLY(5,
+			result = pool->getProcessCount() == 2;
+		);
+		// The next asyncGet() should spawn a new process and the action should be queued.
+		ScopedLock l(pool->syncher);
+		dynamic_pointer_cast<DummySpawner>(group->spawner)->spawnTime = 5000000;
+		pool->asyncGet(options, callback, false);
+		ensure(group->spawning());
+		ensure_equals(group->getWaitlist.size(), 1u);
+		l.unlock();
+		// Close one of the sessions. Now it will process the action.
+		ProcessPtr process = sessions[0]->getProcess();
+		sessions[0].reset();
+		ensure_equals(number, 5);
+		ensure_equals(currentSession->getProcess(), process);
+		ensure_equals(group->getWaitlist.size(), 0u);
+		ensure_equals(pool->getProcessCount(), 2u);
+	}
+	TEST_METHOD(11) {
+		// Here we test the case where the newly spawned process is earlier.
+		// Spawn 2 processes and open 4 sessions.
+		Options options = createOptions();
+		options.minProcesses = 2;
+		pool->setMax(3);
+		GroupPtr group = pool->findOrCreateGroup(options);
+		dynamic_pointer_cast<DummySpawner>(group->spawner)->concurrency = 2;
+		vector<SessionPtr> sessions;
+		int expectedNumber = 1;
+		for (int i = 0; i < 4; i++) {
+			pool->asyncGet(options, callback);
+			EVENTUALLY(5,
+				result = number == expectedNumber;
+			);
+			expectedNumber++;
+			sessions.push_back(currentSession);
+			currentSession.reset();
+		}
+		EVENTUALLY(5,
+			result = pool->getProcessCount() == 2;
+		);
+		// The next asyncGet() should spawn a new process. After it's done
+		// spawning it will process the action.
+		pool->asyncGet(options, callback);
+		EVENTUALLY(5,
+			result = pool->getProcessCount() == 3;
+		);
+		EVENTUALLY(5,
+			result = number == 5;
+		);
+		ensure_equals(currentSession->getProcess()->pid, 3);
+		ensure_equals(group->getWaitlist.size(), 0u);
+	}
+	/*********** Test asyncGet() behavior on multiple SuperGroups,
+	             each with a single Group ***********/
+	TEST_METHOD(20) {
+		// If the pool is full, and one tries to asyncGet() from a nonexistant group,
+		// then it will kill the oldest idle process and spawn a new process.
+		Options options = createOptions();
+		pool->setMax(2);
+		// Get from /foo and close its session immediately.
+		options.appRoot = "/foo";
+		pool->asyncGet(options, callback);
+		EVENTUALLY(5,
+			result = number == 1;
+		);
+		ProcessPtr process1 = currentSession->getProcess();
+		GroupPtr group1 = process1->getGroup();
+		SuperGroupPtr superGroup1 = group1->getSuperGroup();
+		currentSession.reset();
+		// Get from /bar and keep its session open.
+		options.appRoot = "/bar";
+		pool->asyncGet(options, callback);
+		EVENTUALLY(5,
+			result = number == 2;
+		);
+		SessionPtr session2 = currentSession;
+		currentSession.reset();
+		// Get from /baz. The process for /foo should be killed now.
+		options.appRoot = "/baz";
+		pool->asyncGet(options, callback);
+		EVENTUALLY(5,
+			result = number == 3;
+		);
+		ensure_equals(pool->getProcessCount(), 2u);
+		ensure(!superGroup1->detached());
+		ensure_equals(superGroup1->getProcessCount(), 0u);
+	}
+	TEST_METHOD(21) {
+		// If the pool is full, and one tries to asyncGet() from a nonexistant group,
+		// and all existing processes are non-idle, then it will
+		// kill the oldest process and spawn a new process.
+		Options options = createOptions();
+		pool->setMax(2);
+		// Get from /foo and close its session immediately.
+		options.appRoot = "/foo";
+		pool->asyncGet(options, callback);
+		EVENTUALLY(5,
+			result = number == 1;
+		);
+		SessionPtr session1 = currentSession;
+		ProcessPtr process1 = currentSession->getProcess();
+		GroupPtr group1 = process1->getGroup();
+		SuperGroupPtr superGroup1 = group1->getSuperGroup();
+		// Get from /bar and keep its session open.
+		options.appRoot = "/bar";
+		pool->asyncGet(options, callback);
+		EVENTUALLY(5,
+			result = number == 2;
+		);
+		SessionPtr session2 = currentSession;
+		currentSession.reset();
+		// Get from /baz. The process for /foo should be killed now.
+		options.appRoot = "/baz";
+		pool->asyncGet(options, callback);
+		EVENTUALLY(5,
+			result = number == 3;
+		);
+		ensure_equals(pool->getProcessCount(), 2u);
+		ensure(!superGroup1->detached());
+		ensure_equals(superGroup1->getProcessCount(), 0u);
+	}
+	/*********** Test detachProcess() ***********/
+	TEST_METHOD(30) {
+		// detachProcess() detaches the process from the group.
+		Options options = createOptions();
+		options.appGroupName = "test";
+		options.minProcesses = 2;
+		pool->asyncGet(options, callback);
+		EVENTUALLY(5,
+			result = pool->getProcessCount() == 2;
+		);
+		EVENTUALLY(5,
+			result = number == 1;
+		);
+		pool->detachProcess(currentSession->getProcess());
+		ensure(currentSession->getProcess()->detached());
+		LockGuard l(pool->syncher);
+		ensure_equals(pool->superGroups.get("test")->defaultGroup->count, 1);
+	}
+	TEST_METHOD(31) {
+		// If the containing group had waiters on it, and detachProcess()
+		// detaches the only process in the group, then a new process
+		// is automatically spawned to handle the waiters.
+		Options options = createOptions();
+		options.appGroupName = "test";
+		pool->setMax(1);
+		pool->spawnerFactory->dummySpawnTime = 1000000;
+		pool->asyncGet(options, callback);
+		EVENTUALLY(5,
+			result = number == 1;
+		);
+		SessionPtr session1 = currentSession;
+		currentSession.reset();
+		pool->asyncGet(options, callback);
+		{
+			LockGuard l(pool->syncher);
+			ensure_equals(pool->superGroups.get("test")->defaultGroup->getWaitlist.size(), 1u);
+		}
+		pool->detachProcess(session1->getProcess());
+		{
+			LockGuard l(pool->syncher);
+			ensure(pool->superGroups.get("test")->defaultGroup->spawning());
+			ensure_equals(pool->superGroups.get("test")->defaultGroup->count, 0);
+			ensure_equals(pool->superGroups.get("test")->defaultGroup->getWaitlist.size(), 1u);
+		}
+	}
+	TEST_METHOD(32) {
+		// If the pool had waiters on it then detachProcess() will
+		// automatically create the SuperGroups that were requested
+		// by the waiters.
+		Options options = createOptions();
+		options.appGroupName = "test";
+		pool->setMax(1);
+		pool->spawnerFactory->dummySpawnTime = 30000;
+		// Begin spawning a process.
+		pool->asyncGet(options, callback);
+		ensure(pool->atFullCapacity());
+		// asyncGet() on another group should now put it on the waiting list.
+		Options options2 = createOptions();
+		options2.appGroupName = "test2";
+		pool->spawnerFactory->dummySpawnTime = 90000;
+		pool->asyncGet(options2, callback);
+		{
+			LockGuard l(pool->syncher);
+			ensure_equals(pool->getWaitlist.size(), 1u);
+		}
+		// Eventually the dummy process for "test" is now done spawning.
+		// We then detach it.
+		EVENTUALLY(5,
+			result = number == 1;
+		);
+		SessionPtr session1 = currentSession;
+		currentSession.reset();
+		pool->detachProcess(session1->getProcess());
+		{
+			LockGuard l(pool->syncher);
+			ensure(pool->superGroups.get("test2") != NULL);
+			ensure_equals(pool->getWaitlist.size(), 0u);
+		}
+	}
+	TEST_METHOD(33) {
+		// A SuperGroup does not become garbage collectable
+		// after detaching all its processes.
+		Options options = createOptions();
+		pool->asyncGet(options, callback);
+		EVENTUALLY(5,
+			result = number == 1;
+		);
+		ProcessPtr process = currentSession->getProcess();
+		currentSession.reset();
+		SuperGroupPtr superGroup = process->getSuperGroup();
+		pool->detachProcess(process);
+		LockGuard l(pool->syncher);
+		ensure_equals(pool->superGroups.size(), 1u);
+		ensure(!superGroup->detached());
+		ensure(!superGroup->garbageCollectable());
+	}
+	/*********** Test disabling and enabling processes ***********/
+	TEST_METHOD(40) {
+		// Disabling a process under idle conditions should succeed immediately.
+		/*
+		Options options = createOptions();
+		options.minProcesses = 2;
+		options.noop = true;
+		pool->asyncGet(options, callback);
+		EVENTUALLY(5,
+			result = number == 1;
+		);
+		EVENTUALLY(5,
+			result = pool->getProcessCount() == 2;
+		);
+		options.minProcesses = 0;
+		options.noop = false;
+		vector<ProcessPtr> processes = pool->getProcesses();
+		ensure_equals(processes, );
+		*/
+	}
+	// Disabling the sole process in a group should trigger a new process spawn.
+	// Disabling should succeed after the new process has been spawned.
+	// Duppose that a previous disable command triggered a new process spawn,
+	// and the spawn fails. Then the processes which were marked as 'disabled'
+	// should be marked 'enabled' again, and the callbacks for the previous
+	// disable commands should be called.
+	// asyncGet() should not select a process that's being disabled, unless
+	// it's the only process in the group.
+	// Disabling a process that's already being disabled should result in the
+	// callback being called after disabling is done.
+	// Enabling a process that's being disabled should immediately mark the process
+	// as being enabled and should call all the queued disable command callbacks.
+	// Enabling a process that's disabled works.
+	/*********** Other tests ***********/
+	TEST_METHOD(50) {
+		// The pool is considered to be at full capacity if and only
+		// if all SuperGroups are at full capacity.
+		Options options = createOptions();
+		Options options2 = createOptions();
+		options2.appGroupName = "test";
+		pool->setMax(2);
+		pool->asyncGet(options, callback);
+		EVENTUALLY(5,
+			result = number == 1;
+		);
+		pool->asyncGet(options2, callback);
+		EVENTUALLY(5,
+			result = number == 2;
+		);
+		ensure_equals(pool->getProcessCount(), 2u);
+		ensure(pool->atFullCapacity());
+		pool->detachSuperGroup(pool->getSuperGroup("test"));
+		ensure(!pool->atFullCapacity());
+	}
+	TEST_METHOD(51) {
+		// If the pool is at full capacity, then increasing 'max' will cause
+		// new processes to be spawned. Any queued get requests are processed
+		// as those new processes become available or as existing processes
+		// become available.
+		Options options = createOptions();
+		retainSessions = true;
+		pool->setMax(1);
+		pool->asyncGet(options, callback);
+		pool->asyncGet(options, callback);
+		pool->asyncGet(options, callback);
+		EVENTUALLY(5,
+			result = number == 1;
+		);
+		pool->setMax(4);
+		EVENTUALLY(5,
+			result = number == 3;
+		);
+		ensure_equals(pool->getProcessCount(), 3u);
+	}
+	TEST_METHOD(52) {
+		// Each spawned process has a GUPID, which can be looked up
+		// through findProcessByGupid().
+		Options options = createOptions();
+		pool->asyncGet(options, callback);
+		EVENTUALLY(5,
+			result = number == 1;
+		);
+		string gupid = currentSession->getProcess()->gupid;
+		ensure(!gupid.empty());
+		ensure_equals(currentSession->getProcess(), pool->findProcessByGupid(gupid));
+	}
+	TEST_METHOD(53) {
+		// findProcessByGupid() returns a NULL pointer if there is
+		// no matching process.
+		ensure(pool->findProcessByGupid("none") == NULL);
+	}
+	TEST_METHOD(54) {
+		// Test process idle cleaning.
+		Options options = createOptions();
+		retainSessions = true;
+		pool->setMaxIdleTime(50000);
+		pool->asyncGet(options, callback);
+		pool->asyncGet(options, callback);
+		EVENTUALLY(2,
+			result = number == 2;
+		);
+		ensure_equals(pool->getProcessCount(), 2u);
+		currentSession.reset();
+		sessions.pop_back();
+		// One of the processes still has a session open and should
+		// not be idle cleaned.
+		EVENTUALLY(2,
+			result = pool->getProcessCount() == 1;
+		);
+		SHOULD_NEVER_HAPPEN(150,
+			result = pool->getProcessCount() == 0;
+		);
+		// It shouldn't clean more processes than minInstances allows.
+		sessions.clear();
+		SHOULD_NEVER_HAPPEN(150,
+			result = pool->getProcessCount() == 0;
+		);
+	}
+	TEST_METHOD(55) {
+		// Test spawner idle cleaning.
+		Options options = createOptions();
+		options.appGroupName = "test1";
+		Options options2 = createOptions();
+		options2.appGroupName = "test2";
+		retainSessions = true;
+		pool->setMaxIdleTime(50000);
+		pool->asyncGet(options, callback);
+		pool->asyncGet(options2, callback);
+		EVENTUALLY(2,
+			result = number == 2;
+		);
+		ensure_equals(pool->getProcessCount(), 2u);
+		EVENTUALLY(2,
+			SpawnerPtr spawner = pool->getSuperGroup("test1")->defaultGroup->spawner;
+			result = static_pointer_cast<DummySpawner>(spawner)->cleanCount >= 1;
+		);
+		EVENTUALLY(2,
+			SpawnerPtr spawner = pool->getSuperGroup("test2")->defaultGroup->spawner;
+			result = static_pointer_cast<DummySpawner>(spawner)->cleanCount >= 1;
+		);
+	}
+	TEST_METHOD(56) {
+		// It should restart the app if restart.txt is created or updated.
+		TempDirCopy dir("stub/wsgi", "tmp.wsgi");
+		Options options = createOptions();
+		options.appRoot = "tmp.wsgi";
+		options.appType = "wsgi";
+		options.spawnMethod = "direct";
+		ProcessPtr process;
+		pool->setMax(1);
+		// Send normal request.
+		ensure_equals(sendRequest(options, "/"), "hello <b>world</b>");
+		// Modify application; it shouldn't have effect yet.
+		writeFile("tmp.wsgi/passenger_wsgi.py",
+			"def application(env, start_response):\n"
+			"	start_response('200 OK', [('Content-Type', 'text/html')])\n"
+			"	return ['restarted']\n");
+		ensure_equals(sendRequest(options, "/"), "hello <b>world</b>");
+		// Create restart.txt and send request again. The change should now be activated.
+		touchFile("tmp.wsgi/tmp/restart.txt", 1);
+		ensure_equals(sendRequest(options, "/"), "restarted");
+		// Modify application again; it shouldn't have effect yet.
+		writeFile("tmp.wsgi/passenger_wsgi.py",
+			"def application(env, start_response):\n"
+			"	start_response('200 OK', [('Content-Type', 'text/html')])\n"
+			"	return ['restarted 2']\n");
+		ensure_equals(sendRequest(options, "/"), "restarted");
+		// Touch restart.txt and send request again. The change should now be activated.
+		touchFile("tmp.wsgi/tmp/restart.txt", 2);
+		ensure_equals(sendRequest(options, "/"), "restarted 2");
+	}
+	TEST_METHOD(57) {
+		// Test spawn exceptions.
+		TempDirCopy dir("stub/wsgi", "tmp.wsgi");
+		Options options = createOptions();
+		options.appRoot = "tmp.wsgi";
+		options.appType = "wsgi";
+		options.spawnMethod = "direct";
+		spawnerFactory->forwardStderr = false;
+		writeFile("tmp.wsgi/passenger_wsgi.py",
+			"import sys\n"
+			"sys.stderr.write('Something went wrong!')\n"
+			"exit(1)\n");
+		pool->asyncGet(options, callback);
+		EVENTUALLY(5,
+			result = number == 1;
+		);
+		ensure(currentException != NULL);
+		shared_ptr<SpawnException> e = dynamic_pointer_cast<SpawnException>(currentException);
+		ensure_equals(e->getErrorPage(), "Something went wrong!");
+	}
+	TEST_METHOD(58) {
+		// If a process fails to spawn, then it stops trying to spawn minProcesses processes.
+		TempDirCopy dir("stub/wsgi", "tmp.wsgi");
+		Options options = createOptions();
+		options.appRoot = "tmp.wsgi";
+		options.appType = "wsgi";
+		options.spawnMethod = "direct";
+		options.minProcesses = 4;
+		spawnerFactory->forwardStderr = false;
+		writeFile("tmp.wsgi/counter", "0");
+		// Our application starts successfully the first two times,
+		// and fails all the other times.
+		writeFile("tmp.wsgi/passenger_wsgi.py",
+			"import sys\n"
+			"def application(env, start_response):\n"
+			"	pass\n"
+			"counter = int(open('counter', 'r').read())\n"
+			"f = open('counter', 'w')\n"
+			"f.write(str(counter + 1))\n"
+			"f.close()\n"
+			"if counter >= 2:\n"
+			"	sys.stderr.write('Something went wrong!')\n"
+			"	exit(1)\n");
+		pool->asyncGet(options, callback);
+		EVENTUALLY(5,
+			result = number == 1;
+		);
+		EVENTUALLY(5,
+			result = pool->getProcessCount() == 2;
+		);
+		EVENTUALLY(2,
+			result = !pool->getSuperGroup("tmp.wsgi")->defaultGroup->spawning();
+		);
+		SHOULD_NEVER_HAPPEN(500,
+			result = pool->getProcessCount() > 2;
+		);
+	}
+	TEST_METHOD(59) {
+		// It removes the process from the pool if session->initiate() fails.
+		Options options = createOptions();
+		options.appRoot = "stub/wsgi";
+		options.appType = "wsgi";
+		options.spawnMethod = "direct";
+		pool->asyncGet(options, callback);
+		EVENTUALLY(5,
+			result = number == 1;
+		);
+		pid_t pid = currentSession->getPid();
+		kill(pid, SIGTERM);
+		// Wait until process is gone.
+		EVENTUALLY(5,
+			result = kill(pid, 0) == -1 && (errno == ESRCH || errno == EPERM || errno == ECHILD);
+		);
+		try {
+			currentSession->initiate();
+			fail("Initiate is supposed to fail");
+		} catch (const SystemException &e) {
+			ensure_equals(e.code(), ECONNREFUSED);
+		}
+		ensure_equals(pool->getProcessCount(), 0u);
+	}
+	TEST_METHOD(60) {
+		// When a process has become idle, and there are waiters on the pool,
+		// consider detaching it in order to satisfy a waiter.
+		Options options1 = createOptions();
+		Options options2 = createOptions();
+		options2.appRoot = "stub/wsgi";
+		options2.allowTrashingNonIdleProcesses = false;
+		retainSessions = true;
+		pool->setMax(2);
+		pool->asyncGet(options1, callback);
+		pool->asyncGet(options1, callback);
+		EVENTUALLY(3,
+			result = pool->getProcessCount() == 2;
+		);
+		pool->asyncGet(options2, callback);
+		ensure_equals(pool->getWaitlist.size(), 1u);
+		ensure_equals(number, 2);
+		currentSession.reset();
+		sessions.pop_front();
+		EVENTUALLY(3,
+			result = number == 3;
+		);
+		ensure_equals(pool->getProcessCount(), 2u);
+		SuperGroupPtr superGroup1 = pool->superGroups.get("stub/rack");
+		SuperGroupPtr superGroup2 = pool->superGroups.get("stub/rack");
+		ensure_equals(superGroup1->defaultGroup->count, 1);
+		ensure_equals(superGroup2->defaultGroup->count, 1);
+	}
+	TEST_METHOD(61) {
+		// A process is detached after processing maxRequests sessions.
+		{
+			Ticket ticket;
+			Options options = createOptions();
+			options.maxRequests = 5;
+			pool->setMax(1);
+			pool->get(options, &ticket).reset();
+			vector<ProcessPtr> processes = pool->getProcesses();
+			ensure_equals(processes.size(), 1u);
+			pid_t origPid = processes[0]->pid;
+			for (int i = 0; i < 3; i++) {
+				pool->get(options, &ticket).reset();
+				processes = pool->getProcesses();
+				ensure_equals(processes.size(), 1u);
+				ensure_equals(processes[0]->pid, origPid);
+			}
+			pool->get(options, &ticket).reset();
+		}
+		EVENTUALLY(2,
+			result = pool->getProcessCount() == 0;
+		);
+	}
+	TEST_METHOD(62) {
+		// If we restart while spawning is in progress, then the spawn
+		// loop will exit as soon as it has detected that we're restarting.
+		TempDirCopy dir("stub/wsgi", "tmp.wsgi");
+		spawnerFactory->dummySpawnTime = 20000;
+		spawnerFactory->dummySpawnerCreationSleepTime = 100000;
+		Options options = createOptions();
+		options.appRoot = "tmp.wsgi";
+		options.minProcesses = 3;
+		// Trigger spawn loop. The spawn loop itself won't take longer than 3*20=60 msec.
+		pool->findOrCreateGroup(options);
+		ScopedLock l(pool->syncher);
+		pool->asyncGet(options, callback, false);
+		// Wait until spawn loop tries to grab the lock.
+		EVENTUALLY(3,
+			LockGuard l2(pool->debugSyncher);
+			result = pool->spawnLoopIteration == 1;
+		);
+		l.unlock();
+		// At this point, the spawn loop is about to attach its first spawned
+		// process to the group. We wait until it has succeeded doing so.
+		// Remaining maximum time in the spawn loop: 2*20=40 msec.
+		EVENTUALLY2(200, 0,
+			result = pool->getProcessCount() == 1;
+		);
+		// Trigger restart. It will immediately detach the sole process in the pool,
+		// and it will finish after approximately 100 msec,
+		// allowing the spawn loop to detect that the restart flag is true.
+		touchFile("tmp.wsgi/tmp/restart.txt");
+		pool->asyncGet(options, callback);
+		ensure_equals("(1)", pool->getProcessCount(), 0u);
+		// The spawn loop will succeed at spawning the second process.
+		// Upon attaching it, it should detect the restart the stop,
+		// so that it never spawns the third process.
+		SHOULD_NEVER_HAPPEN(300,
+			LockGuard l2(pool->debugSyncher);
+			result = pool->spawnLoopIteration > 2;
+		);
+		ensure_equals("(2)", pool->getProcessCount(), 1u);
+	}
+	TEST_METHOD(63) {
+		// If a get() request comes in while the restart is in progress, then
+		// that get() request will be put into the get waiters list, which will
+		// be processed after spawning is done.
+		// Spawn 2 processes.
+		TempDirCopy dir("stub/wsgi", "tmp.wsgi");
+		Options options = createOptions();
+		options.appRoot = "tmp.wsgi";
+		options.minProcesses = 2;
+		pool->asyncGet(options, callback);
+		EVENTUALLY(2,
+			result = pool->getProcessCount() == 2;
+		);
+		// Trigger a restart. The creation of the new spawner should take a while.
+		spawnerFactory->dummySpawnerCreationSleepTime = 20000;
+		touchFile("tmp.wsgi/tmp/restart.txt");
+		pool->asyncGet(options, callback);
+		GroupPtr group = pool->findOrCreateGroup(options);
+		ensure_equals(pool->getProcessCount(), 0u);
+		ensure_equals(group->getWaitlist.size(), 1u);
+		// Now that the restart is in progress, perform a get().
+		pool->asyncGet(options, callback);
+		ensure_equals(group->getWaitlist.size(), 2u);
+		EVENTUALLY(2,
+			result = number == 3;
+		);
+		ensure_equals("The restart function respects minProcesses",
+			pool->getProcessCount(), 2u);
+	}
+	TEST_METHOD(64) {
+		// If a process fails to spawn, it sends a SpawnException result to all get waiters.
+		TempDirCopy dir("stub/wsgi", "tmp.wsgi");
+		Options options = createOptions();
+		options.appRoot = "tmp.wsgi";
+		options.appType = "wsgi";
+		options.spawnMethod = "direct";
+		spawnerFactory->forwardStderr = false;
+		pool->setMax(1);
+		writeFile("tmp.wsgi/passenger_wsgi.py",
+			"import os, time, sys\n"
+			"\n"
+			"def file_exists(filename):\n"
+			"	try:\n"
+			"		os.stat(filename)\n"
+			"		return True\n"
+			"	except OSError:\n"
+			"		return False\n"
+			"\n"
+			"f = open('spawned.txt', 'w')\n"
+			"f.write(str(os.getpid()))\n"
+			"f.close()\n"
+			"while not file_exists('continue.txt'):\n"
+			"	time.sleep(0.05)\n"
+			"sys.stderr.write('Something went wrong!')\n"
+			"exit(1)\n");
+		retainSessions = true;
+		pool->asyncGet(options, callback);
+		pool->asyncGet(options, callback);
+		pool->asyncGet(options, callback);
+		pool->asyncGet(options, callback);
+		EVENTUALLY(5,
+			result = fileExists("tmp.wsgi/spawned.txt");
+		);
+		usleep(20000);
+		writeFile("tmp.wsgi/passenger_wsgi.py", readAll("stub/wsgi/passenger_wsgi.py"));
+		pid_t pid = (pid_t) stringToLL(readAll("tmp.wsgi/spawned.txt"));
+		kill(pid, SIGTERM);
+		EVENTUALLY(5,
+			result = number == 4;
+		);
+		ensure_equals(pool->getProcessCount(), 0u);
+		ensure(sessions.empty());
+	}
+	TEST_METHOD(65) {
+		// If a process fails to spawn, the existing processes
+		// are kept alive.
+		TempDirCopy dir("stub/wsgi", "tmp.wsgi");
+		Options options = createOptions();
+		options.appRoot = "tmp.wsgi";
+		options.appType = "wsgi";
+		options.spawnMethod = "direct";
+		options.minProcesses = 2;
+		spawnerFactory->forwardStderr = false;
+		// Spawn 2 processes.
+		retainSessions = true;
+		pool->asyncGet(options, callback);
+		pool->asyncGet(options, callback);
+		EVENTUALLY(5,
+			result = number == 2;
+		);
+		ensure_equals(pool->getProcessCount(), 2u);
+		// Mess up the application and spawn a new one.
+		writeFile("tmp.wsgi/passenger_wsgi.py",
+			"import sys\n"
+			"sys.stderr.write('Something went wrong!')\n"
+			"exit(1)\n");
+		try {
+			Ticket ticket;
+			currentSession = pool->get(options, &ticket);
+			fail("SpawnException expected");
+		} catch (const SpawnException &) {
+			ensure_equals(pool->getProcessCount(), 2u);
+		}
+	}
+	// Persistent connections.
+	// If one closes the session before it has reached EOF, and process's maximum concurrency
+	// has already been reached, then the pool should ping the process so that it can detect
+	// when the session's connection has been released by the app.
+	/*****************************/
+}