passenger 2.2.2 → 2.2.3

data/lib/phusion_passenger/railz/request_handler.rb

@@ -28,7 +28,10 @@ module Railz
 
 # A request handler for Ruby on Rails applications.
 class RequestHandler < AbstractRequestHandler
-	NINJA_PATCHING_LOCK = Mutex.new
+	CONTENT_LENGTH      = 'CONTENT_LENGTH'      # :nodoc:
+	HTTP_CONTENT_LENGTH = 'HTTP_CONTENT_LENGTH' # :nodoc:
+	
+	NINJA_PATCHING_LOCK = Mutex.new             # :nodoc:
 	@@ninja_patched_action_controller = false
 	
 	def initialize(owner_pipe, options = {})
@@ -41,6 +44,7 @@ class RequestHandler < AbstractRequestHandler
 protected
 	# Overrided method.
 	def process_request(headers, input, output)
+		headers[CONTENT_LENGTH] = headers[HTTP_CONTENT_LENGTH]
 		cgi = CGIFixed.new(headers, input, output)
 		::Dispatcher.dispatch(cgi,
 			::ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS,

data/lib/phusion_passenger/spawn_manager.rb

@@ -97,7 +97,7 @@ class SpawnManager < AbstractServer
 	#
 	# Other options are:
 	#
-	# ['lower_privilege', 'lowest_user' and 'environment']
+	# ['lower_privilege', 'lowest_user', 'environment', 'environment_variables', 'base_uri' and 'print_exceptions']
 	#   See Railz::ApplicationSpawner.new for an explanation of these options.
 	# 
 	# ['app_type']
@@ -234,7 +234,11 @@ private
 			else
 				key = "version:#{framework_version}"
 				create_spawner = proc do
-					Railz::FrameworkSpawner.new(:version => framework_version)
+					framework_options = { :version => framework_version }
+					if options.has_key?(:print_framework_loading_exceptions)
+						framework_options[:print_framework_loading_exceptions] = options[:print_framework_loading_exceptions]
+					end
+					Railz::FrameworkSpawner.new(framework_options)
 				end
 				spawner_timeout = options["framework_spawner_timeout"]
 			end

data/lib/phusion_passenger/utils.rb

@@ -154,10 +154,10 @@ protected
 	#
 	# +current_location+ is a string which describes where the code is
 	# currently at. Usually the current class name will be enough.
-	def print_exception(current_location, exception)
+	def print_exception(current_location, exception, destination = STDERR)
 		if !exception.is_a?(SystemExit)
-			STDERR.puts(exception.backtrace_string(current_location))
-			STDERR.flush
+			destination.puts(exception.backtrace_string(current_location))
+			destination.flush if destination.respond_to?(:flush)
 		end
 	end
 	
@@ -178,9 +178,11 @@ protected
 				if double_fork
 					pid2 = fork
 					if pid2.nil?
+						srand
 						yield
 					end
 				else
+					srand
 					yield
 				end
 			rescue Exception => e
@@ -201,9 +203,21 @@ protected
 	# Run the given block. A message will be sent through +channel+ (a
 	# MessageChannel object), telling the remote side whether the block
 	# raised an exception, called exit(), or succeeded.
-	# Returns whether the block succeeded.
-	# Exceptions are not propagated, except for SystemExit.
-	def report_app_init_status(channel)
+	#
+	# Anything written to $stderr and STDERR during execution of the block
+	# will be buffered. If <tt>write_stderr_contents_to</tt> is non-nil,
+	# then the buffered stderr data will be written to this object. In this
+	# case, <tt>write_stderr_contents_to</tt> must be an IO-like object.
+	# If <tt>write_stderr_contents_to</tt> is nil, then the stder data will
+	# be discarded.
+	# 
+	# Returns whether the block succeeded, i.e. whether it didn't raise an
+	# exception.
+	#
+	# Exceptions are not propagated, except SystemExit and a few
+	# non-StandardExeption classes such as SignalException. Of the
+	# exceptions that are propagated, only SystemExit will be reported.
+	def report_app_init_status(channel, write_stderr_contents_to = STDERR)
 		begin
 			old_global_stderr = $stderr
 			old_stderr = STDERR
@@ -218,10 +232,13 @@ protected
 				Object.send(:remove_const, 'STDERR') rescue nil
 				Object.const_set('STDERR', old_stderr)
 				$stderr = old_global_stderr
-				if tempfile
-					tempfile.rewind
-					stderr_output = tempfile.read
-					tempfile.close rescue nil
+				tempfile.rewind
+				stderr_output = tempfile.read
+				tempfile.close rescue nil
+				
+				if write_stderr_contents_to
+					write_stderr_contents_to.write(stderr_output)
+					write_stderr_contents_to.flush
 				end
 			end
 			channel.write('success')
@@ -247,10 +264,24 @@ protected
 	# received information, then an appropriate exception will be
 	# raised.
 	#
+	# If <tt>print_exception</tt> evaluates to true, then the
+	# exception message and the backtrace will also be printed.
+	# Where it is printed to depends on the type of
+	# <tt>print_exception</tt>:
+	# - If it responds to #puts, then the exception information will
+	#   be printed using this method.
+	# - If it responds to #to_str, then the exception information
+	#   will be appended to the file whose filename equals the return
+	#   value of the #to_str call.
+	# - Otherwise, it will be printed to STDERR.
+	#
 	# Raises:
-	# - AppInitError
-	# - IOError, SystemCallError, SocketError
-	def unmarshal_and_raise_errors(channel, app_type = "rails")
+	# - AppInitError: this class wraps the exception information
+	#   received through the channel.
+	# - IOError, SystemCallError, SocketError: these errors are
+	#   raised if an error occurred while receiving the information
+	#   through the channel.
+	def unmarshal_and_raise_errors(channel, print_exception = nil, app_type = "rails")
 		args = channel.read
 		if args.nil?
 			raise EOFError, "Unexpected end-of-file detected."
@@ -259,8 +290,7 @@ protected
 		if status == 'exception'
 			child_exception = unmarshal_exception(channel.read_scalar)
 			stderr = channel.read_scalar
-			#print_exception(self.class.to_s, child_exception)
-			raise AppInitError.new(
+			exception = AppInitError.new(
 				"Application '#{@app_root}' raised an exception: " <<
 				"#{child_exception.class} (#{child_exception.message})",
 				child_exception,
@@ -269,9 +299,25 @@ protected
 		elsif status == 'exit'
 			child_exception = unmarshal_exception(channel.read_scalar)
 			stderr = channel.read_scalar
-			raise AppInitError.new("Application '#{@app_root}' exited during startup",
+			exception = AppInitError.new("Application '#{@app_root}' exited during startup",
 				child_exception, app_type, stderr.empty? ? nil : stderr)
+		else
+			exception = nil
+		end
+		
+		if print_exception && exception
+			if print_exception.respond_to?(:puts)
+				print_exception(self.class.to_s, child_exception, print_exception)
+			elsif print_exception.respond_to?(:to_str)
+				filename = print_exception.to_str
+				File.open(filename, 'a') do |f|
+					print_exception(self.class.to_s, child_exception, f)
+				end
+			else
+				print_exception(self.class.to_s, child_exception)
+			end
 		end
+		raise exception if exception
 	end
 	
 	# Lower the current process's privilege to the owner of the given file.
@@ -320,6 +366,10 @@ protected
 		end
 	end
 	
+	def to_boolean(value)
+		return !(value.nil? || value == false || value == "false")
+	end
+	
 	def sanitize_spawn_options(options)
 		defaults = {
 			"lower_privilege" => true,
@@ -328,12 +378,15 @@ protected
 			"app_type"        => "rails",
 			"spawn_method"    => "smart-lv2",
 			"framework_spawner_timeout" => -1,
-			"app_spawner_timeout"       => -1
+			"app_spawner_timeout"       => -1,
+			"print_exceptions" => true
 		}
 		options = defaults.merge(options)
-		options["lower_privilege"]           = options["lower_privilege"].to_s == "true"
+		options["lower_privilege"]           = to_boolean(options["lower_privilege"])
 		options["framework_spawner_timeout"] = options["framework_spawner_timeout"].to_i
 		options["app_spawner_timeout"]       = options["app_spawner_timeout"].to_i
+		# Force this to be a boolean for easy use with Utils#unmarshal_and_raise_errors.
+		options["print_exceptions"]          = to_boolean(options["print_exceptions"])
 		return options
 	end
 	
@@ -367,6 +420,8 @@ protected
 	def self.passenger_tmpdir=(dir)
 		@@passenger_tmpdir = dir
 	end
+	
+	####################################
 end
 
 end # module PhusionPassenger
@@ -479,16 +534,13 @@ end
 module Signal
 	# Like Signal.list, but only returns signals that we can actually trap.
 	def self.list_trappable
-		ruby_engine = defined?(RUBY_ENGINE) ? RUBY_ENGINE : "mri"
+		ruby_engine = defined?(RUBY_ENGINE) ? RUBY_ENGINE : "ruby"
 		case ruby_engine
-		when "mri"
-			if RUBY_VERSION >= '1.9.0'
-				return Signal.list
-			else
-				result = Signal.list
-				result.delete("ALRM")
-				return result
-			end
+		when "ruby"
+			result = Signal.list
+			result.delete("ALRM")
+			result.delete("VTALRM")
+			return result
 		when "jruby"
 			result = Signal.list
 			result.delete("QUIT")

data/misc/rake/cplusplus.rb

@@ -23,11 +23,11 @@
 
 # Rake functions for compiling/linking C++ stuff.
 
-def compile_c(source, flags = CXXFLAGS)
-	sh "#{CXX} #{flags} -c #{source}"
+def compile_c(source, flags = "#{PlatformInfo.portability_cflags} #{EXTRA_CXXFLAGS}")
+	sh "#{CC} #{flags} -c #{source}"
 end
 
-def compile_cxx(source, flags = CXXFLAGS)
+def compile_cxx(source, flags = "#{PlatformInfo.portability_cflags} #{EXTRA_CXXFLAGS}")
 	sh "#{CXX} #{flags} -c #{source}"
 end
 
@@ -43,11 +43,11 @@ def create_static_library(target, sources)
 	sh "ranlib #{target}"
 end
 
-def create_executable(target, sources, linkflags = LDFLAGS)
+def create_executable(target, sources, linkflags = "#{PlatformInfo.portability_cflags} #{EXTRA_CXXFLAGS} #{PlatformInfo.portability_ldflags} #{EXTRA_LDFLAGS}")
 	sh "#{CXX} #{sources} -o #{target} #{linkflags}"
 end
 
-def create_shared_library(target, sources, flags = LDFLAGS)
+def create_shared_library(target, sources, flags = "#{PlatformInfo.portability_cflags} #{EXTRA_CXXFLAGS} #{PlatformInfo.portability_ldflags} #{EXTRA_LDFLAGS}")
 	if RUBY_PLATFORM =~ /darwin/
 		shlib_flag = "-flat_namespace -bundle -undefined dynamic_lookup"
 	else

data/test/ApplicationPoolServerTest.cpp

@@ -68,5 +68,47 @@ namespace tut {
 			}
 		}
 	}
+	
+	/* A StringListCreator which not only returns a dummy value, but also
+	 * increments a counter each time getItems() is called. */
+	class DummyStringListCreator: public StringListCreator {
+	public:
+		mutable int counter;
+		
+		DummyStringListCreator() {
+			counter = 0;
+		}
+		
+		virtual const StringListPtr getItems() const {
+			StringListPtr result = ptr(new StringList());
+			counter++;
+			result->push_back("hello");
+			result->push_back("world");
+			return result;
+		}
+	};
+	
+	TEST_METHOD(5) {
+		// When calling get() with a PoolOptions object,
+		// options.environmentVariables->getItems() isn't called unless
+		// the pool had to spawn something.
+		ApplicationPoolServerPtr server = ptr(new ApplicationPoolServer(
+			"./ApplicationPoolServerExecutable",
+			"../bin/passenger-spawn-server"));
+		ApplicationPoolPtr pool = server->connect();
+		
+		shared_ptr<DummyStringListCreator> strList = ptr(new DummyStringListCreator());
+		PoolOptions options("stub/rack");
+		options.appType = "rack";
+		options.environmentVariables = strList;
+		
+		Application::SessionPtr session1 = pool->get(options);
+		session1.reset();
+		ensure_equals(strList->counter, 1);
+		
+		session1 = pool->get(options);
+		session1.reset();
+		ensure_equals(strList->counter, 1);
+	}
 }
 

data/test/ApplicationPoolTest.cpp

@@ -12,7 +12,8 @@
  * This file is used as a template to test the different ApplicationPool implementations.
  * It is #included in StandardApplicationPoolTest.cpp and ApplicationServer_ApplicationPoolTest.cpp
  */
-#ifdef USE_TEMPLATE	
+#ifdef USE_TEMPLATE
+	/** Create some stub request headers. */
 	static string createRequestHeaders(const char *uri = "/foo/new") {
 		string headers;
 		#define ADD_HEADER(name, value) \
@@ -25,29 +26,11 @@
 		ADD_HEADER("REQUEST_URI", uri);
 		ADD_HEADER("REQUEST_METHOD", "GET");
 		ADD_HEADER("REMOTE_ADDR", "localhost");
+		ADD_HEADER("SCRIPT_NAME", "");
 		ADD_HEADER("PATH_INFO", uri);
 		return headers;
 	}
 	
-	static string readAll(int fd) {
-		string result;
-		char buf[1024 * 32];
-		ssize_t ret;
-		while (true) {
-			do {
-				ret = read(fd, buf, sizeof(buf));
-			} while (ret == -1 && errno == EINTR);
-			if (ret == 0) {
-				break;
-			} else if (ret == -1) {
-				throw SystemException("Cannot read from socket", errno);
-			} else {
-				result.append(buf, ret);
-			}
-		}
-		return result;
-	}
-	
 	static Application::SessionPtr spawnRackApp(ApplicationPoolPtr pool, const char *appRoot) {
 		PoolOptions options;
 		options.appRoot = appRoot;
@@ -61,17 +44,17 @@
 		options.appType = "wsgi";
 		return pool->get(options);
 	}
-
+	
 	TEST_METHOD(1) {
 		// Calling ApplicationPool.get() once should return a valid Session.
-		Application::SessionPtr session(pool->get("stub/railsapp"));
+		Application::SessionPtr session(spawnRackApp(pool, "stub/rack"));
 		session->sendHeaders(createRequestHeaders());
 		session->shutdownWriter();
 
 		int reader = session->getStream();
 		string result(readAll(reader));
 		session->closeStream();
-		ensure(result.find("hello world") != string::npos);
+		ensure(result.find("hello <b>world</b>") != string::npos);
 	}
 	
 	TEST_METHOD(2) {
@@ -99,26 +82,29 @@
 		// If we call get() with an application root, then we call get() again before closing
 		// the session, then the pool should have spawned 2 apps in total.
 		Application::SessionPtr session(spawnRackApp(pool, "stub/rack"));
-		Application::SessionPtr session2(spawnRackApp(pool, "stub/rack"));
+		Application::SessionPtr session2(spawnRackApp(pool2, "stub/rack"));
 		ensure_equals(pool->getCount(), 2u);
 	}
 	
 	TEST_METHOD(5) {
 		// If we call get() twice with different application roots,
 		// then the pool should spawn two different apps.
-		Application::SessionPtr session(pool->get("stub/railsapp"));
-		Application::SessionPtr session2(pool2->get("stub/railsapp2"));
+		TempDirCopy c1("stub/rack", "rackapp1.tmp");
+		TempDirCopy c2("stub/rack", "rackapp2.tmp");
+		replaceStringInFile("rackapp2.tmp/config.ru", "world", "world 2");
+		Application::SessionPtr session(spawnRackApp(pool, "rackapp1.tmp"));
+		Application::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);
 		
 		session->sendHeaders(createRequestHeaders());
 		string result(readAll(session->getStream()));
-		ensure("Session 1 belongs to the correct app", result.find("hello world") != string::npos);
+		ensure("Session 1 belongs to the correct app", result.find("hello <b>world</b>") != string::npos);
 		session.reset();
 		
 		session2->sendHeaders(createRequestHeaders());
 		result = readAll(session2->getStream());
-		ensure("Session 2 belongs to the correct app", result.find("this is railsapp2") != string::npos);
+		ensure("Session 2 belongs to the correct app", result.find("hello <b>world 2</b>") != string::npos);
 		session2.reset();
 	}
 	
@@ -126,12 +112,14 @@
 		// If we call get() twice with different application roots,
 		// and we close both sessions, then both 2 apps should still
 		// be in the pool.
-		Application::SessionPtr session(pool->get("stub/railsapp"));
-		Application::SessionPtr session2(pool->get("stub/railsapp2"));
+		TempDirCopy c1("stub/rack", "rackapp1.tmp");
+		TempDirCopy c2("stub/rack", "rackapp2.tmp");
+		Application::SessionPtr session(spawnRackApp(pool, "rackapp1.tmp"));
+		Application::SessionPtr session2(spawnRackApp(pool, "rackapp2.tmp"));
 		session.reset();
 		session2.reset();
-		ensure_equals(pool->getActive(), 0u);
-		ensure_equals(pool->getCount(), 2u);
+		ensure_equals("There are 0 active apps", pool->getActive(), 0u);
+		ensure_equals("There are 2 apps in total", pool->getCount(), 2u);
 	}
 	
 	TEST_METHOD(7) {
@@ -150,26 +138,26 @@
 		// But the get() thereafter should not:
 		// ApplicationPool should have spawned a new instance
 		// after detecting that the original one died.
-		Application::SessionPtr session(pool->get("stub/railsapp"));
+		Application::SessionPtr session(spawnRackApp(pool, "stub/rack"));
 		kill(session->getPid(), SIGTERM);
 		session.reset();
 		try {
-			session = pool->get("stub/railsapp");
+			session = spawnRackApp(pool, "stub/rack");
 			fail("ApplicationPool::get() is supposed to "
 				"throw an exception because we killed "
 				"the app instance.");
 		} catch (const exception &e) {
-			session = pool->get("stub/railsapp");
+			session = spawnRackApp(pool, "stub/rack");
 			// Should not throw.
 		}
 	}
 	
-	struct TestThread1 {
+	struct PoolWaitTestThread {
 		ApplicationPoolPtr pool;
 		Application::SessionPtr &m_session;
 		bool &m_done;
 		
-		TestThread1(const ApplicationPoolPtr &pool,
+		PoolWaitTestThread(const ApplicationPoolPtr &pool,
 			Application::SessionPtr &session,
 			bool &done)
 		: m_session(session), m_done(done) {
@@ -194,12 +182,13 @@
 		Application::SessionPtr session3;
 		bool done;
 		
-		thread *thr = new thread(TestThread1(pool2, session3, done));
+		shared_ptr<thread> thr = ptr(new thread(PoolWaitTestThread(pool2, session3, done)));
 		usleep(500000);
-		ensure("ApplicationPool is waiting", !done);
+		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();
 		
 		// Wait at most 10 seconds.
@@ -213,7 +202,7 @@
 		ensure_equals(pool->getCount(), 2u);
 		
 		thr->join();
-		delete thr;
+		thr.reset();
 	}
 	
 	TEST_METHOD(10) {
@@ -221,25 +210,27 @@
 		// * the pool is already full, but there are inactive apps
 		//   (active < count && count == max)
 		// and
-		// * the application root is *not* already in the pool
+		// * the application root 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");
 		pool->setMax(2);
-		Application::SessionPtr session1(pool->get("stub/railsapp"));
-		Application::SessionPtr session2(pool->get("stub/railsapp"));
+		Application::SessionPtr session1(spawnRackApp(pool, "rackapp1.tmp"));
+		Application::SessionPtr session2(spawnRackApp(pool, "rackapp1.tmp"));
 		session1.reset();
 		session2.reset();
 		
 		ensure_equals(pool->getActive(), 0u);
 		ensure_equals(pool->getCount(), 2u);
-		session1 = pool2->get("stub/railsapp2");
+		session1 = spawnRackApp(pool, "rackapp2.tmp");
 		ensure_equals(pool->getActive(), 1u);
 		ensure_equals(pool->getCount(), 2u);
 	}
 	
 	TEST_METHOD(11) {
-		// Test whether Session is still usable after the Application has been destroyed.
-		Application::SessionPtr session(pool->get("stub/railsapp"));
+		// A Session should still be usable after the pool has been destroyed.
+		Application::SessionPtr session(spawnRackApp(pool, "stub/rack"));
 		pool->clear();
 		pool.reset();
 		pool2.reset();
@@ -250,32 +241,27 @@
 		int reader = session->getStream();
 		string result(readAll(reader));
 		session->closeStream();
-		ensure(result.find("hello world") != string::npos);
+		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;
-		Application::SessionPtr session1 = pool->get("stub/railsapp");
-		Application::SessionPtr session2 = pool2->get("stub/railsapp");
+		TempDirCopy c("stub/rack", "rackapp.tmp");
+		Application::SessionPtr session1 = spawnRackApp(pool, "rackapp.tmp");
+		Application::SessionPtr session2 = spawnRackApp(pool, "rackapp.tmp");
 		session1.reset();
 		session2.reset();
 		
-		system("touch stub/railsapp/tmp/restart.txt");
-		pool->get("stub/railsapp");
+		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);
-		try {
-			ensure("Restart file still exists",
-				stat("stub/railsapp/tmp/restart.txt", &buf) == 0);
-			unlink("stub/railsapp/tmp/restart.txt");
-		} catch (...) {
-			unlink("stub/railsapp/tmp/restart.txt");
-			throw;
-		}
+		ensure("Restart file still exists",
+			stat("rackapp.tmp/tmp/restart.txt", &buf) == 0);
 	}
 	
 	TEST_METHOD(13) {
@@ -284,56 +270,213 @@
 		// 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");
+		Application::SessionPtr session = spawnRackApp(pool, "rackapp.tmp");
+		old_pid = session->getPid();
+		session.reset();
 		
-		system("mkdir -p stub/railsapp/tmp/restart.txt");
-		try {
-			Application::SessionPtr session = pool->get("stub/railsapp");
-			old_pid = session->getPid();
-			session.reset();
-			
-			struct utimbuf buf;
-			buf.actime = time(NULL) - 10;
-			buf.modtime = time(NULL) - 10;
-			utime("stub/railsapp/tmp/restart.txt", &buf);
-			
-			session = pool->get("stub/railsapp");
-			ensure("The app was restarted", session->getPid() != old_pid);
-			old_pid = session->getPid();
-			session.reset();
-			
-			session = pool->get("stub/railsapp");
-			ensure_equals("The app was not restarted",
-				old_pid, session->getPid());
-		} catch (...) {
-			system("rmdir stub/railsapp/tmp/restart.txt");
-			throw;
-		}
+		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();
+		
+		session = spawnRackApp(pool, "rackapp.tmp");
+		ensure_equals("The app was not restarted",
+			old_pid, session->getPid());
 	}
 	
 	TEST_METHOD(15) {
-		// Test whether restarting really results in code reload.
-		DeleteFileEventually f1("stub/railsapp/app/controllers/bar_controller.rb");
-		DeleteFileEventually f2("stub/railsapp/tmp/restart.txt");
-		
-		system("cp -f stub/railsapp/app/controllers/bar_controller_1.txt "
-			"stub/railsapp/app/controllers/bar_controller.rb");
-		Application::SessionPtr session = pool->get("stub/railsapp");
-		session->sendHeaders(createRequestHeaders("/bar"));
+		// Test whether restarting with restart.txt really results in code reload.
+		TempDirCopy c("stub/rack", "rackapp.tmp");
+		Application::SessionPtr session = spawnRackApp(pool, "rackapp.tmp");
+		session->sendHeaders(createRequestHeaders());
 		string result = readAll(session->getStream());
-		ensure(result.find("bar 1!") != string::npos);
+		ensure(result.find("hello <b>world</b>") != string::npos);
 		session.reset();
 		
-		system("cp -f stub/railsapp/app/controllers/bar_controller_2.txt "
-			"stub/railsapp/app/controllers/bar_controller.rb");
-		system("touch stub/railsapp/tmp/restart.txt");
+		touchFile("rackapp.tmp/tmp/restart.txt");
+		replaceStringInFile("rackapp.tmp/config.ru", "world", "world 2");
 		
-		session = pool->get("stub/railsapp");
-		session->sendHeaders(createRequestHeaders("/bar"));
+		session = spawnRackApp(pool, "rackapp.tmp");
+		session->sendHeaders(createRequestHeaders());
 		result = readAll(session->getStream());
-		ensure("App code has been reloaded", result.find("bar 2!") != string::npos);
+		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");
+		Application::SessionPtr session1 = spawnRackApp(pool, "rackapp.tmp");
+		Application::SessionPtr session2 = spawnRackApp(pool2, "rackapp.tmp");
+		session1.reset();
+		session2.reset();
+		
+		touchFile("rackapp.tmp/tmp/always_restart.txt");
+		
+		// This get() results in a restart.
+		session1 = spawnRackApp(pool, "rackapp.tmp");
+		old_pid = session1->getPid();
+		session1.reset();
+		ensure_equals("First restart: no apps are active", 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();
+		ensure_equals("Second restart: no apps are active", 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");
+		Application::SessionPtr session1 = spawnRackApp(pool, "rackapp.tmp");
+		Application::SessionPtr session2 = spawnRackApp(pool, "rackapp.tmp");
+		session1.reset();
+		session2.reset();
+		
+		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();
+		ensure_equals("First restart: no apps are active", 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();
+		ensure_equals("Second restart: no apps are active", 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");
+		Application::SessionPtr session = spawnRackApp(pool, "rackapp.tmp");
+		session->sendHeaders(createRequestHeaders());
+		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");
+		session->sendHeaders(createRequestHeaders());
+		result = readAll(session->getStream());
+		ensure("App code has been reloaded (1)", result.find("hello <b>world 2</b>") != string::npos);
+		session.reset();
+		
+		replaceStringInFile("rackapp.tmp/config.ru", "world 2", "world 3");
+		session = spawnRackApp(pool, "rackapp.tmp");
+		session->sendHeaders(createRequestHeaders());
+		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");
+		Application::SessionPtr session1 = spawnRackApp(pool, "rackapp.tmp");
+		Application::SessionPtr session2 = spawnRackApp(pool2, "rackapp.tmp");
+		session1.reset();
+		session2.reset();
+		
+		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);
+		
+		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";
+		
+		Application::SessionPtr session1 = pool->get(options);
+		Application::SessionPtr session2 = pool2->get(options);
+		session1.reset();
+		session2.reset();
+		
+		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";
+		
+		Application::SessionPtr session1 = pool->get(options);
+		Application::SessionPtr session2 = pool2->get(options);
+		session1.reset();
+		session2.reset();
+		
+		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 without crashing.
 		pool->setMaxIdleTime(1);
 		spawnRackApp(pool, "stub/rack");
@@ -345,7 +488,7 @@
 		ensure_equals("App should have been cleaned up", pool->getCount(), 0u);
 	}
 	
-	TEST_METHOD(17) {
+	TEST_METHOD(23) {
 		// MaxPerApp is respected.
 		pool->setMax(3);
 		pool->setMaxPerApp(1);
@@ -359,18 +502,20 @@
 		
 		// We connect to stub/wsgi. Assert that the pool spawns a new
 		// instance for this app.
+		TempDirCopy c("stub/wsgi", "wsgiapp.tmp");
 		ApplicationPoolPtr pool3(newPoolConnection());
-		Application::SessionPtr session3 = spawnWsgiApp(pool3, "stub/wsgi");
+		Application::SessionPtr session3 = spawnWsgiApp(pool3, "wsgiapp.tmp");
 		ensure_equals(pool->getCount(), 2u);
 	}
 	
-	TEST_METHOD(18) {
+	TEST_METHOD(24) {
 		// Application instance is shutdown after 'maxRequests' requests.
-		PoolOptions options("stub/railsapp");
+		PoolOptions options("stub/rack");
 		int reader;
 		pid_t originalPid;
 		Application::SessionPtr session;
 		
+		options.appType = "rack";
 		options.maxRequests = 4;
 		pool->setMax(1);
 		session = pool->get(options);
@@ -411,7 +556,7 @@
 		}
 	};
 	
-	TEST_METHOD(19) {
+	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.
@@ -439,171 +584,14 @@
 		thr.join();
 	}
 	
-	TEST_METHOD(20) {
-		// If tmp/always_restart.txt is present, then the application under app_root
-		// should be always restarted.
-		try {
-			struct stat buf;
-			Application::SessionPtr session1 = pool->get("stub/railsapp");
-			Application::SessionPtr session2 = pool2->get("stub/railsapp");
-			session1.reset();
-			session2.reset();
-		
-			system("touch stub/railsapp/tmp/always_restart.txt");
-			pool->get("stub/railsapp");
-		
-			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("always_restart file has not been deleted",
-				stat("stub/railsapp/tmp/always_restart.txt", &buf) == 0);
-			unlink("stub/railsapp/tmp/always_restart.txt");
-		} catch (...) {
-			unlink("stub/railsapp/tmp/always_restart.txt");
-			throw;
-		}
-	}
-	
-	TEST_METHOD(21) {
-		// If tmp/always_restart.txt is present and is a directory, 
-		// then the application under app_root
-		// should be always restarted.
-		try {
-			struct stat buf;
-			Application::SessionPtr session1 = pool->get("stub/railsapp");
-			Application::SessionPtr session2 = pool2->get("stub/railsapp");
-			session1.reset();
-			session2.reset();
-		
-			system("mkdir stub/railsapp/tmp/always_restart.txt");
-			pool->get("stub/railsapp");
-		
-			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("always_restart file has not been deleted",
-				stat("stub/railsapp/tmp/always_restart.txt", &buf) == 0);
-			system("rmdir stub/railsapp/tmp/always_restart.txt");
-		} catch (...) {
-			system("rmdir stub/railsapp/tmp/always_restart.txt");
-			throw;
-		}
-	}
-	
-	TEST_METHOD(22) {
-		// Test whether tmp/always_restart.txt really results in code reload.
-		DeleteFileEventually f1("stub/railsapp/app/controllers/bar_controller.rb");
-		DeleteFileEventually f2("stub/railsapp/tmp/always_restart.txt");
-		
-		system("cp -f stub/railsapp/app/controllers/bar_controller_1.txt "
-			"stub/railsapp/app/controllers/bar_controller.rb");
-		Application::SessionPtr session = pool->get("stub/railsapp");
-		session->sendHeaders(createRequestHeaders("/bar"));
-		string result = readAll(session->getStream());
-		ensure(result.find("bar 1!") != string::npos);
-		session.reset();
-
-		system("cp -f stub/railsapp/app/controllers/bar_controller_2.txt "
-			"stub/railsapp/app/controllers/bar_controller.rb");
-		system("touch stub/railsapp/tmp/always_restart.txt");
-		session = pool->get("stub/railsapp");
-		session->sendHeaders(createRequestHeaders("/bar"));
-		result = readAll(session->getStream());
-		ensure("App code has been reloaded (1)", result.find("bar 2!") != string::npos);
-		session.reset();
-
-		system("cp -f stub/railsapp/app/controllers/bar_controller_1.txt "
-			"stub/railsapp/app/controllers/bar_controller.rb");
-		session = pool->get("stub/railsapp");
-		session->sendHeaders(createRequestHeaders("/bar"));
-		result = readAll(session->getStream());
-		ensure("App code has been reloaded (2)", result.find("bar 1!") != string::npos);
-		session.reset();
-	}
-	
-	TEST_METHOD(23) {
-		// 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
-		try {
-			pid_t old_pid, pid;
-			struct stat buf;
-			Application::SessionPtr session1 = pool->get("stub/railsapp");
-			Application::SessionPtr session2 = pool2->get("stub/railsapp");
-			session1.reset();
-			session2.reset();
-		
-			system("touch stub/railsapp/tmp/restart.txt");
-			system("touch stub/railsapp/tmp/always_restart.txt");
-		
-			old_pid = pool->get("stub/railsapp")->getPid();
-			ensure("always_restart file has not been deleted",
-				stat("stub/railsapp/tmp/always_restart.txt", &buf) == 0);
-
-			ensure("Restart file has not been deleted",
-				stat("stub/railsapp/tmp/restart.txt", &buf) == 0);
-		
-			pid = pool->get("stub/railsapp")->getPid();
-			ensure("The app was restarted", pid != old_pid);
-
-			unlink("stub/railsapp/tmp/restart.txt");
-			unlink("stub/railsapp/tmp/always_restart.txt");
-		} catch (...) {
-			unlink("stub/railsapp/tmp/restart.txt");
-			unlink("stub/railsapp/tmp/always_restart.txt");
-			throw;
-		}
-	}
-	
-	TEST_METHOD(24) {
-		// 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";
-		
-		Application::SessionPtr session1 = pool->get(options);
-		Application::SessionPtr session2 = pool2->get(options);
-		session1.reset();
-		session2.reset();
-		
-		DeleteFileEventually f("stub/rack/restart.txt");
-		system("touch 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(25) {
-		// restartDir may also be a directory relative to the
-		// application root.
-		struct stat buf;
-		PoolOptions options("stub/rack");
-		options.appType = "rack";
-		options.restartDir = "public";
-		
-		Application::SessionPtr session1 = pool->get(options);
-		Application::SessionPtr session2 = pool2->get(options);
-		session1.reset();
-		session2.reset();
-		
-		DeleteFileEventually f("stub/rack/public/restart.txt");
-		system("touch 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(26) {
+		// When a previous application domain 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.
+		
+		// TODO: to test this we first need to be able to move
+		// ApplicationPoolServer in-process so that we can use mock objects
 	}
 	
 	/*************************************/