passenger 4.0.48 → 4.0.49

data/test/cxx/ApplicationPool2/DirectSpawnerTest.cpp

@@ -14,7 +14,7 @@ namespace tut {
 		PipeWatcher::DataCallback gatherOutput;
 		string gatheredOutput;
 		boost::mutex gatheredOutputSyncher;
-		
+
 		ApplicationPool2_DirectSpawnerTest() {
 			createServerInstanceDirAndGeneration(serverInstanceDir, generation);
 			PipeWatcher::onData = PipeWatcher::DataCallback();
@@ -29,12 +29,12 @@ namespace tut {
 			unlink("stub/wsgi/passenger_wsgi.pyc");
 			PipeWatcher::onData = PipeWatcher::DataCallback();
 		}
-		
+
 		boost::shared_ptr<DirectSpawner> createSpawner(const Options &options) {
 			return boost::make_shared<DirectSpawner>(
 				generation, make_shared<SpawnerConfig>(*resourceLocator));
 		}
-		
+
 		Options createOptions() {
 			Options options;
 			options.spawnMethod = "direct";
@@ -49,9 +49,9 @@ namespace tut {
 	};
 
 	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
@@ -61,10 +61,10 @@ namespace tut {
 		options.startCommand = "perl\t" "-e\t" "print STDERR \"hello world\\n\"; sleep(60)";
 		options.startupFile  = ".";
 		options.startTimeout = 300;
-		
+
 		DirectSpawner spawner(generation, make_shared<SpawnerConfig>(*resourceLocator));
 		setLogLevel(LVL_CRIT);
-		
+
 		try {
 			process = spawner.spawn(options);
 			process->requiresShutdown = false;
@@ -75,7 +75,7 @@ namespace tut {
 			ensure(e.getErrorPage().find("hello world\n") != string::npos);
 		}
 	}
-	
+
 	TEST_METHOD(81) {
 		// If the application crashed during startup without returning
 		// a proper error response, then its stderr output is used
@@ -84,10 +84,10 @@ namespace tut {
 		options.appRoot      = "stub";
 		options.startCommand = "perl\t" "-e\t" "print STDERR \"hello world\\n\"";
 		options.startupFile  = ".";
-		
+
 		DirectSpawner spawner(generation, make_shared<SpawnerConfig>(*resourceLocator));
 		setLogLevel(LVL_CRIT);
-		
+
 		try {
 			process = spawner.spawn(options);
 			process->requiresShutdown = false;
@@ -111,7 +111,7 @@ namespace tut {
 		process = spawner->spawn(options);
 		process->requiresShutdown = false;
 		ensure_equals(process->sockets->size(), 1u);
-		
+
 		Connection conn = process->sockets->front().checkoutConnection();
 		ScopeGuard guard(boost::bind(checkin, process, &conn));
 		writeExact(conn.fd, "ping\n");

data/test/cxx/ApplicationPool2/OptionsTest.cpp

@@ -10,9 +10,9 @@ namespace tut {
 		ApplicationPool2_OptionsTest() {
 		}
 	};
-	
+
 	DEFINE_TEST_GROUP(ApplicationPool2_OptionsTest);
-	
+
 	TEST_METHOD(1) {
 		// Test persist().
 		char appRoot[] = "appRoot";
@@ -21,18 +21,18 @@ namespace tut {
 		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);

data/test/cxx/ApplicationPool2/PoolTest.cpp

@@ -29,7 +29,7 @@ namespace tut {
 		boost::mutex syncher;
 		list<SessionPtr> sessions;
 		bool retainSessions;
-		
+
 		ApplicationPool2_PoolTest() {
 			createServerInstanceDirAndGeneration(serverInstanceDir, generation);
 			retainSessions = false;
@@ -42,7 +42,7 @@ namespace tut {
 			setLogLevel(LVL_ERROR); // TODO: change to LVL_WARN
 			setPrintAppOutputAsDebuggingMessages(true);
 		}
-		
+
 		~ApplicationPool2_PoolTest() {
 			// Explicitly destroy these here because they can run
 			// additional code that depend on other fields in this
@@ -62,7 +62,7 @@ namespace tut {
 			pool->initDebugging();
 			debug = pool->debugSupport;
 		}
-		
+
 		void clearAllSessions() {
 			SessionPtr myCurrentSession;
 			list<SessionPtr> mySessions;
@@ -89,7 +89,7 @@ namespace tut {
 			options.defaultGroup = testConfig["default_group"].asCString();
 			return options;
 		}
-		
+
 		void _callback(const SessionPtr &session, const ExceptionPtr &e) {
 			SessionPtr oldSession;
 			{
@@ -125,7 +125,7 @@ namespace tut {
 			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);
 		}
 
@@ -184,31 +184,31 @@ namespace tut {
 			*result = (int) pool->disableProcess(process->gupid);
 		}
 	};
-	
+
 	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;
 		);
@@ -216,37 +216,37 @@ namespace tut {
 		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->busyness(), 0);
 		ensure(!process->isTotallyBusy());
-		
+
 		// 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();
@@ -261,13 +261,13 @@ namespace tut {
 		currentSession.reset();
 		ensure_equals(process->sessions, 1);
 		ensure(process->isTotallyBusy());
-		
+
 		// 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);
@@ -275,7 +275,7 @@ namespace tut {
 			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 utilization,
 		// and the limits and pool capacity allow spawning of a new process,
@@ -283,23 +283,23 @@ namespace tut {
 		// 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.
 		initPoolDebugging();
-		
+
 		// Spawn a regular process and keep its session open.
 		Options options = createOptions();
 		debug->messages->send("Proceed with spawn loop iteration 1");
 		SessionPtr session1 = pool->get(options, &ticket);
 		ProcessPtr process1 = session1->getProcess();
-		
+
 		// Now spawn a process that never finishes.
 		pool->asyncGet(options, callback);
-		
+
 		// Release the session on the first process.
 		session1.reset();
-		
+
 		EVENTUALLY(1,
 			result = number == 1;
 		);
@@ -311,11 +311,11 @@ namespace tut {
 			result = number == 1;
 		);
 	}
-	
+
 	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);
@@ -325,7 +325,7 @@ namespace tut {
 		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);
@@ -335,11 +335,11 @@ namespace tut {
 		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;
@@ -353,7 +353,7 @@ namespace tut {
 		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);
@@ -364,7 +364,7 @@ namespace tut {
 		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();
@@ -377,11 +377,11 @@ namespace tut {
 		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;
@@ -395,14 +395,14 @@ namespace tut {
 		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);
@@ -411,7 +411,7 @@ namespace tut {
 		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);
@@ -419,7 +419,7 @@ namespace tut {
 		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);
@@ -429,20 +429,20 @@ namespace tut {
 		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);
 		spawnerConfig->concurrency = 2;
-		
+
 		vector<SessionPtr> sessions;
 		int expectedNumber = 1;
 		for (int i = 0; i < 4; i++) {
@@ -457,16 +457,16 @@ namespace tut {
 		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 utilization.
 		sessions[0].reset();
@@ -474,7 +474,7 @@ namespace tut {
 			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 utilization,
 		// and a new process may be spawned,
@@ -484,14 +484,14 @@ namespace tut {
 		// 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);
 		spawnerConfig->concurrency = 2;
-		
+
 		vector<SessionPtr> sessions;
 		int expectedNumber = 1;
 		for (int i = 0; i < 4; i++) {
@@ -506,7 +506,7 @@ namespace tut {
 		EVENTUALLY(5,
 			result = pool->getProcessCount() == 2;
 		);
-		
+
 		// The next asyncGet() should spawn a new process and the action should be queued.
 		ScopedLock l(pool->syncher);
 		spawnerConfig->spawnTime = 5000000;
@@ -514,7 +514,7 @@ namespace tut {
 		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();
@@ -523,17 +523,17 @@ namespace tut {
 		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);
 		spawnerConfig->concurrency = 2;
-		
+
 		vector<SessionPtr> sessions;
 		int expectedNumber = 1;
 		for (int i = 0; i < 4; i++) {
@@ -548,7 +548,7 @@ namespace tut {
 		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);
@@ -585,7 +585,7 @@ namespace tut {
 		// Test shutting down while Group is spawning.
 		initPoolDebugging();
 		Options options = createOptions();
-		
+
 		pool->asyncGet(options, callback);
 		debug->debugger->recv("Begin spawn loop iteration 1");
 		ensure(pool->detachSuperGroupByName("stub/rack"));
@@ -651,17 +651,17 @@ namespace tut {
 		);
 		ensure_equals(pool->getProcessCount(), 1u);
 	}
-	
-	
+
+
 	/*********** 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);
@@ -672,7 +672,7 @@ namespace tut {
 		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);
@@ -681,25 +681,25 @@ namespace tut {
 		);
 		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_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);
@@ -709,7 +709,7 @@ namespace tut {
 		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);
@@ -718,14 +718,14 @@ namespace tut {
 		);
 		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_equals(superGroup1->getProcessCount(), 0u);
 	}
@@ -935,10 +935,10 @@ namespace tut {
 			result = number == 2;
 		);
 	}
-	
-	
+
+
 	/*********** Test detachProcess() ***********/
-	
+
 	TEST_METHOD(30) {
 		// detachProcess() detaches the process from the group. The pool
 		// will restore the minimum number of processes afterwards.
@@ -967,7 +967,7 @@ namespace tut {
 			result = process->isDead();
 		);
 	}
-	
+
 	TEST_METHOD(31) {
 		// If the containing group had waiters on it, and detachProcess()
 		// detaches the only process in the group, then a new process
@@ -985,7 +985,7 @@ namespace tut {
 		currentSession.reset();
 
 		pool->asyncGet(options, callback);
-		
+
 		{
 			LockGuard l(pool->syncher);
 			ensure_equals(pool->superGroups.get("test")->defaultGroup->getWaitlist.size(), 1u);
@@ -1003,7 +1003,7 @@ namespace tut {
 			result = number == 2;
 		);
 	}
-	
+
 	TEST_METHOD(32) {
 		// If the pool had waiters on it then detachProcess() will
 		// automatically create the SuperGroups that were requested
@@ -1046,7 +1046,7 @@ namespace tut {
 			result = number == 2;
 		);
 	}
-	
+
 	TEST_METHOD(33) {
 		// A SuperGroup does not become garbage collectable
 		// after detaching all its processes.
@@ -1131,7 +1131,47 @@ namespace tut {
 		);
 	}
 
-	
+	TEST_METHOD(36) {
+		// Detaching a process that is already being detached, works.
+		Options options = createOptions();
+		options.appGroupName = "test";
+		options.minProcesses = 0;
+
+		initPoolDebugging();
+		debug->restarting = false;
+		debug->spawning   = false;
+		debug->detachedProcessesChecker = true;
+
+		pool->asyncGet(options, callback);
+		EVENTUALLY(5,
+			result = pool->getProcessCount() == 1;
+		);
+		EVENTUALLY(5,
+			result = number == 1;
+		);
+
+		ProcessPtr process = currentSession->getProcess();
+		pool->detachProcess(currentSession->getProcess());
+		debug->debugger->recv("About to start detached processes checker");
+		{
+			LockGuard l(pool->syncher);
+			ensure(process->enabled == Process::DETACHED);
+		}
+
+		pool->detachProcess(currentSession->getProcess());
+		debug->messages->send("Proceed with starting detached processes checker");
+		debug->messages->send("Proceed with starting detached processes checker");
+
+		EVENTUALLY(5,
+			result = pool->getProcessCount() == 0;
+		);
+		currentSession.reset();
+		EVENTUALLY(5,
+			result = process->isDead();
+		);
+	}
+
+
 	/*********** Test disabling and enabling processes ***********/
 
 	TEST_METHOD(40) {
@@ -1140,7 +1180,7 @@ namespace tut {
 		vector<ProcessPtr> processes = pool->getProcesses();
 		ensure_equals("Disabling succeeds",
 			pool->disableProcess(processes[0]->gupid), DR_SUCCESS);
-		
+
 		LockGuard l(pool->syncher);
 		ensure(processes[0]->isAlive());
 		ensure_equals("Process is disabled",
@@ -1322,7 +1362,7 @@ namespace tut {
 	// TODO: Enabling a process that's disabled succeeds immediately.
 	// TODO: Enabling a process that's disabling succeeds immediately. The disable
 	//       callbacks will be called with DR_CANCELED.
-	
+
 	TEST_METHOD(51) {
 		// If the number of processes is already at maximum, then disabling
 		// a process will cause that process to be disabled, without spawning
@@ -1344,9 +1384,9 @@ namespace tut {
 		}
 	}
 
-	
+
 	/*********** Other tests ***********/
-	
+
 	TEST_METHOD(60) {
 		// The pool is considered to be at full capacity if and only
 		// if all SuperGroups are at full capacity.
@@ -1371,7 +1411,7 @@ namespace tut {
 		pool->detachSuperGroupByName("test");
 		ensure(!pool->atFullCapacity());
 	}
-	
+
 	TEST_METHOD(61) {
 		// If the pool is at full capacity, then increasing 'max' will cause
 		// new processes to be spawned. Any queued get requests are processed
@@ -1394,7 +1434,7 @@ namespace tut {
 		);
 		ensure_equals(pool->getProcessCount(), 3u);
 	}
-	
+
 	TEST_METHOD(62) {
 		// Each spawned process has a GUPID, which can be looked up
 		// through findProcessByGupid().
@@ -1407,7 +1447,7 @@ namespace tut {
 		ensure(!gupid.empty());
 		ensure_equals(currentSession->getProcess(), pool->findProcessByGupid(gupid));
 	}
-	
+
 	TEST_METHOD(63) {
 		// findProcessByGupid() returns a NULL pointer if there is
 		// no matching process.
@@ -1423,7 +1463,7 @@ namespace tut {
 		ensure_equals(pool->getProcessCount(), 2u);
 
 		session2.reset();
-		
+
 		// One of the processes still has a session open and should
 		// not be idle cleaned.
 		EVENTUALLY(2,
@@ -1455,7 +1495,7 @@ namespace tut {
 			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;
@@ -1584,7 +1624,7 @@ namespace tut {
 			result = number == 1;
 		);
 		pid_t pid = currentSession->getPid();
-		
+
 		kill(pid, SIGTERM);
 		// Wait until process is gone.
 		EVENTUALLY(5,
@@ -1713,7 +1753,7 @@ namespace tut {
 		EVENTUALLY(2,
 			result = pool->getProcessCount() == 2;
 		);
-		
+
 		// Trigger a restart. The creation of the new spawner should take a while.
 		spawnerConfig->spawnerCreationSleepTime = 20000;
 		touchFile("tmp.wsgi/tmp/restart.txt");
@@ -1918,7 +1958,7 @@ namespace tut {
 
 	TEST_METHOD(79) {
 		// Test sticky sessions.
-		
+
 		// Spawn 2 processes and get their sticky session IDs and PIDs.
 		ensureMinProcesses(2);
 		Options options = createOptions();
@@ -1974,9 +2014,9 @@ namespace tut {
 	//       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.
 
-	
+
 	/*********** Test previously discovered bugs ***********/
-	
+
 	TEST_METHOD(85) {
 		// Test detaching, then restarting. This should not violate any invariants.
 		TempDirCopy dir("stub/wsgi", "tmp.wsgi");