passenger 1.0.5 → 2.0.1

data/lib/passenger/railz/framework_spawner.rb

@@ -0,0 +1,344 @@
+#  Phusion Passenger - http://www.modrails.com/
+#  Copyright (C) 2008  Phusion
+#
+#  Phusion Passenger is a trademark of Hongli Lai & Ninh Bui.
+#
+#  This program is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation; version 2 of the License.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License along
+#  with this program; if not, write to the Free Software Foundation, Inc.,
+#  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+require 'rubygems'
+require 'passenger/abstract_server'
+require 'passenger/railz/application_spawner'
+require 'passenger/exceptions'
+require 'passenger/constants'
+require 'passenger/utils'
+module Passenger
+module Railz
+
+# This class is capable of spawning Ruby on Rails application instances
+# quickly. This is done by preloading the Ruby on Rails framework into memory,
+# before spawning the application instances.
+#
+# A single FrameworkSpawner instance can only hold a single Ruby on Rails
+# framework version. So be careful when using FrameworkSpawner: the applications
+# that you spawn through it must require the same RoR version. To handle multiple
+# RoR versions, use multiple FrameworkSpawner instances.
+#
+# FrameworkSpawner uses ApplicationSpawner internally.
+#
+# *Note*: FrameworkSpawner may only be started asynchronously with AbstractServer#start.
+# Starting it synchronously with AbstractServer#start_synchronously has not been tested.
+class FrameworkSpawner < AbstractServer
+	include Utils
+	
+	# This exception means that the FrameworkSpawner server process exited unexpectedly.
+	class Error < AbstractServer::ServerError
+	end
+	
+	# An attribute, used internally. This should not be used outside Passenger.
+	attr_accessor :time
+
+	# Creates a new instance of FrameworkSpawner.
+	#
+	# Valid options:
+	# - <tt>:version</tt>: The Ruby on Rails version to use. It is not checked whether
+	#   this version is actually installed.
+	# - <tt>:vendor</tt>: The directory to the vendor Rails framework to use. This is
+	#   usually something like "/webapps/foo/vendor/rails".
+	#
+	# It is not allowed to specify both +version+ and +vendor+.
+	#
+	# Note that the specified Rails framework will be loaded during the entire life time
+	# of the FrameworkSpawner server. If you wish to reload the Rails framework's code,
+	# then restart the server by calling AbstractServer#stop and AbstractServer#start.
+	def initialize(options = {})
+		if !options.respond_to?(:'[]')
+			raise ArgumentError, "The 'options' argument not seem to be an options hash"
+		end
+		@version = options[:version]
+		@vendor = options[:vendor]
+		if !@version && !@vendor
+			raise ArgumentError, "Either the 'version' or the 'vendor' option must specified"
+		elsif @version && @vendor
+			raise ArgumentError, "It is not allowed to specify both the 'version' and the 'vendor' options"
+		end
+		
+		super()
+		define_message_handler(:spawn_application, :handle_spawn_application)
+		define_message_handler(:reload, :handle_reload)
+	end
+	
+	# Overrided from AbstractServer#start.
+	#
+	# May raise these additional exceptions:
+	# - FrameworkInitError: The specified Ruby on Rails framework could not be loaded.
+	# - FrameworkSpawner::Error: The FrameworkSpawner server exited unexpectedly.
+	def start
+		super
+		begin
+			status = server.read[0]
+			if status == 'exception'
+				child_exception = unmarshal_exception(server.read_scalar)
+				stop
+				if @version
+					message = "Could not load Ruby on Rails framework version #{@version}: " <<
+						"#{child_exception.class} (#{child_exception.message})"
+				else
+					message = "Could not load Ruby on Rails framework at '#{@vendor}': " <<
+						"#{child_exception.class} (#{child_exception.message})"
+				end
+				options = { :vendor => @vendor, :version => @version }
+				raise FrameworkInitError.new(message, child_exception, options)
+			end
+		rescue IOError, SystemCallError, SocketError
+			stop
+			raise Error, "The framework spawner server exited unexpectedly"
+		end
+	end
+	
+	# Spawn a RoR application using the Ruby on Rails framework
+	# version associated with this FrameworkSpawner.
+	# When successful, an Application object will be returned, which represents
+	# the spawned RoR application.
+	#
+	# See ApplicationSpawner.new for an explanation of the +lower_privilege+,
+	# +lowest_user+ and +environment+ parameters.
+	#
+	# FrameworkSpawner will internally cache the code of applications, in order to
+	# speed up future spawning attempts. This implies that, if you've changed
+	# the application's code, you must do one of these things:
+	# - Restart this FrameworkSpawner by calling AbstractServer#stop, then AbstractServer#start.
+	# - Reload the application by calling reload with the correct app_root argument.
+	#
+	# Raises:
+	# - AbstractServer::ServerNotStarted: The FrameworkSpawner server hasn't already been started.
+	# - ArgumentError: +app_root+ doesn't appear to be a valid Ruby on Rails application root.
+	# - AppInitError: The application raised an exception or called exit() during startup.
+	# - ApplicationSpawner::Error: The ApplicationSpawner server exited unexpectedly.
+	# - FrameworkSpawner::Error: The FrameworkSpawner server exited unexpectedly.
+	def spawn_application(app_root, lower_privilege = true, lowest_user = "nobody", environment = "production")
+		app_root = normalize_path(app_root)
+		assert_valid_app_root(app_root)
+		exception_to_propagate = nil
+		begin
+			server.write("spawn_application", app_root, lower_privilege, lowest_user, environment)
+			result = server.read
+			if result.nil?
+				raise IOError, "Connection closed"
+			end
+			if result[0] == 'exception'
+				raise unmarshal_exception(server.read_scalar)
+			else
+				pid, listen_socket_name, using_abstract_namespace = server.read
+				if pid.nil?
+					raise IOError, "Connection closed"
+				end
+				owner_pipe = server.recv_io
+				return Application.new(app_root, pid, listen_socket_name,
+					using_abstract_namespace == "true", owner_pipe)
+			end
+		rescue SystemCallError, IOError, SocketError => e
+			raise Error, "The framework spawner server exited unexpectedly"
+		end
+	end
+	
+	# Remove the cached application instances at the given application root.
+	# If nil is specified as application root, then all cached application
+	# instances will be removed, no matter the application root.
+	#
+	# <b>Long description:</b>
+	# Application code might be cached in memory by a FrameworkSpawner. But
+	# once it a while, it will be necessary to reload the code for an
+	# application, such as after deploying a new version of the application.
+	# This method makes sure that any cached application code is removed, so
+	# that the next time an application instance is spawned, the application
+	# code will be freshly loaded into memory.
+	#
+	# Raises:
+	# - ArgumentError: +app_root+ doesn't appear to be a valid Ruby on Rails
+	#   application root.
+	# - FrameworkSpawner::Error: The FrameworkSpawner server exited unexpectedly.
+	def reload(app_root = nil)
+		if app_root.nil?
+			server.write("reload")
+		else
+			server.write("reload", normalize_path(app_root))
+		end
+	rescue SystemCallError, IOError, SocketError
+		raise Error, "The framework spawner server exited unexpectedly"
+	end
+
+protected
+	# Overrided method.
+	def before_fork # :nodoc:
+		if GC.copy_on_write_friendly?
+			# Garbage collect now so that the child process doesn't have to
+			# do that (to prevent making pages dirty).
+			GC.start
+		end
+	end
+
+	# Overrided method.
+	def initialize_server # :nodoc:
+		$0 = "Passenger FrameworkSpawner: #{@version || @vendor}"
+		@spawners = {}
+		@spawners_lock = Mutex.new
+		@spawners_cond = ConditionVariable.new
+		@spawners_cleaner = Thread.new do
+			begin
+				spawners_cleaner_main_loop
+			rescue Exception => e
+				print_exception(self.class.to_s, e)
+			end
+		end
+		begin
+			preload_rails
+		rescue StandardError, ScriptError, NoMemoryError => e
+			client.write('exception')
+			client.write_scalar(marshal_exception(e))
+			return
+		end
+		client.write('success')
+	end
+	
+	# Overrided method.
+	def finalize_server # :nodoc:
+		@spawners_lock.synchronize do
+			@spawners_cond.signal
+		end
+		@spawners_cleaner.join
+		@spawners.each_value do |spawner|
+			spawner.stop
+		end
+	end
+
+private
+	def preload_rails
+		Object.const_set(:RAILS_ROOT, ".")
+		if @version
+			gem 'rails', "=#{@version}"
+			require 'initializer'
+		else
+			$LOAD_PATH.unshift("#{@vendor}/railties/builtin/rails_info")
+			Dir["#{@vendor}/*"].each do |entry|
+				next unless File.directory?(entry)
+				$LOAD_PATH.unshift("#{entry}/lib")
+			end
+			require "#{@vendor}/railties/lib/initializer"
+		end
+		require 'active_support'
+		require 'active_record'
+		require 'action_controller'
+		require 'action_view'
+		require 'action_pack'
+		require 'action_mailer'
+		require 'dispatcher'
+		begin
+			if ::Rails::VERSION::MAJOR >= 2
+				require 'active_resource'
+			else
+				require 'action_web_service'
+			end
+			require 'ruby_version_check'
+			require 'active_support/whiny_nil'
+		rescue NameError
+			# Rails < 1.1
+			require 'action_web_service'
+		end
+		Object.send(:remove_const, :RAILS_ROOT)
+	end
+
+	def handle_spawn_application(app_root, lower_privilege, lowest_user, environment)
+		lower_privilege = lower_privilege == "true"
+		@spawners_lock.synchronize do
+			spawner = @spawners[app_root]
+			if spawner.nil?
+				begin
+					spawner = ApplicationSpawner.new(app_root,
+						lower_privilege, lowest_user,
+						environment)
+					spawner.start
+				rescue ArgumentError, AppInitError, ApplicationSpawner::Error => e
+					client.write('exception')
+					client.write_scalar(marshal_exception(e))
+					if e.child_exception.is_a?(LoadError)
+						# A source file failed to load, maybe because of a
+						# missing gem. If that's the case then the sysadmin
+						# will install probably the gem. So we clear RubyGems's
+						# cache so that it can detect new gems.
+						Gem.clear_paths
+					end
+					return
+				end
+				@spawners[app_root] = spawner
+			end
+			spawner.time = Time.now
+			begin
+				app = spawner.spawn_application
+			rescue ApplicationSpawner::Error => e
+				spawner.stop
+				@spawners.delete(app_root)
+				client.write('exception')
+				client.write_scalar(marshal_exception(e))
+				return
+			end
+			client.write('success')
+			client.write(app.pid, app.listen_socket_name, app.using_abstract_namespace?)
+			client.send_io(app.owner_pipe)
+			app.close
+		end
+	end
+	
+	def handle_reload(app_root = nil)
+		@spawners_lock.synchronize do
+			if app_root.nil?
+				@spawners.each_value do |spawner|
+					spawner.stop
+				end
+				@spawners.clear
+			else
+				spawner = @spawners[app_root]
+				if spawner
+					spawner.stop
+					@spawners.delete(app_root)
+				end
+			end
+		end
+	end
+	
+	# The main loop for the spawners cleaner thread.
+	# This thread checks the spawners list every APP_SPAWNER_CLEAN_INTERVAL seconds,
+	# and stops application spawners that have been idle for more than
+	# APP_SPAWNER_MAX_IDLE_TIME seconds.
+	def spawners_cleaner_main_loop
+		@spawners_lock.synchronize do
+			while true
+				if @spawners_cond.timed_wait(@spawners_lock, APP_SPAWNER_CLEAN_INTERVAL)
+					break
+				else
+					current_time = Time.now
+					@spawners.keys.each do |key|
+						spawner = @spawners[key]
+						if current_time - spawner.time > APP_SPAWNER_MAX_IDLE_TIME
+							spawner.stop
+							@spawners.delete(key)
+						end
+					end
+				end
+			end
+		end
+	end
+end
+
+end # module Railz
+end # module Passenger

data/lib/passenger/railz/request_handler.rb

@@ -0,0 +1,61 @@
+#  Phusion Passenger - http://www.modrails.com/
+#  Copyright (C) 2008  Phusion
+#
+#  This program is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation; version 2 of the License.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License along
+#  with this program; if not, write to the Free Software Foundation, Inc.,
+#  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+require 'passenger/abstract_request_handler'
+require 'passenger/railz/cgi_fixed'
+module Passenger
+module Railz
+
+# A request handler for Ruby on Rails applications.
+class RequestHandler < AbstractRequestHandler
+	NINJA_PATCHING_LOCK = Mutex.new
+	@@ninja_patched_action_controller = false
+	
+	def initialize(owner_pipe)
+		super(owner_pipe)
+		NINJA_PATCHING_LOCK.synchronize do
+			ninja_patch_action_controller
+		end
+	end
+
+protected
+	# Overrided method.
+	def process_request(headers, input, output)
+		cgi = CGIFixed.new(headers, input, output)
+		::Dispatcher.dispatch(cgi,
+			::ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS,
+			cgi.stdoutput)
+	end
+	
+private
+	def ninja_patch_action_controller
+		if !@@ninja_patched_action_controller && defined?(::ActionController::Base) \
+		&& ::ActionController::Base.private_method_defined?(:perform_action)
+			@@ninja_patched_action_controller = true
+			::ActionController::Base.class_eval do
+				alias passenger_orig_perform_action perform_action
+				
+				def perform_action(*whatever)
+					headers[X_POWERED_BY] = PASSENGER_HEADER
+					passenger_orig_perform_action(*whatever)
+				end
+			end
+		end
+	end
+end
+
+end # module Railz
+end # module Passenger

data/lib/passenger/simple_benchmarking.rb

@@ -1,6 +1,8 @@
 #  Phusion Passenger - http://www.modrails.com/
 #  Copyright (C) 2008  Phusion
 #
+#  Phusion Passenger is a trademark of Hongli Lai & Ninh Bui.
+#
 #  This program is free software; you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by
 #  the Free Software Foundation; version 2 of the License.

data/lib/passenger/spawn_manager.rb

@@ -1,6 +1,8 @@
 #  Phusion Passenger - http://www.modrails.com/
 #  Copyright (C) 2008  Phusion
 #
+#  Phusion Passenger is a trademark of Hongli Lai & Ninh Bui.
+#
 #  This program is free software; you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by
 #  the Free Software Foundation; version 2 of the License.
@@ -15,34 +17,32 @@
 #  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
 require 'passenger/abstract_server'
-require 'passenger/framework_spawner'
-require 'passenger/application'
-require 'passenger/message_channel'
-require 'passenger/html_template'
+require 'passenger/constants'
 require 'passenger/utils'
-require 'passenger/platform_info'
 module Passenger
 
-# This class is capable of spawning Ruby on Rails application instances.
-# Spawning a Ruby on Rails application is usually slow. But SpawnManager
-# will preload and cache Ruby on Rails frameworks, as well as application
-# code, so subsequent spawns will be very fast.
-#
-# Internally, SpawnManager uses FrameworkSpawner to preload and cache
-# Ruby on Rails frameworks. FrameworkSpawner, in turn, uses
-# ApplicationSpawner to preload and cache application code.
+# The spawn manager is capable of spawning Ruby on Rails or Rack application
+# instances. It acts like a simple fascade for the rest of the spawn manager
+# system.
 #
 # *Note*: SpawnManager may only be started synchronously with
 # AbstractServer#start_synchronously. Starting asynchronously has not been
 # tested. Don't forget to call cleanup after the server's main loop has
 # finished.
+#
+# == Ruby on Rails optimizations ===
+#
+# Spawning a Ruby on Rails application is usually slow. But SpawnManager
+# will preload and cache Ruby on Rails frameworks, as well as application
+# code, so subsequent spawns will be very fast.
+#
+# Internally, SpawnManager uses Railz::FrameworkSpawner to preload and cache
+# Ruby on Rails frameworks. Railz::FrameworkSpawner, in turn, uses
+# Railz::ApplicationSpawner to preload and cache application code.
+#
+# In case you're wondering why the namespace is "Railz" and not "Rails":
+# it's to work around an obscure bug in ActiveSupport's Dispatcher.
 class SpawnManager < AbstractServer
-	DEFAULT_INPUT_FD = 3
-	FRAMEWORK_SPAWNER_MAX_IDLE_TIME = 30 * 60
-	APP_SPAWNER_MAX_IDLE_TIME = FrameworkSpawner::APP_SPAWNER_MAX_IDLE_TIME
-	SPAWNER_CLEAN_INTERVAL = [FRAMEWORK_SPAWNER_MAX_IDLE_TIME,
-		APP_SPAWNER_MAX_IDLE_TIME].min + 5
-	
 	include Utils
 	
 	def initialize
@@ -56,19 +56,42 @@ class SpawnManager < AbstractServer
 		define_message_handler(:spawn_application, :handle_spawn_application)
 		define_message_handler(:reload, :handle_reload)
 		define_signal_handler('SIGHUP', :reload)
+		
+		GC.start
+		if GC.copy_on_write_friendly?
+			# Preload libraries for copy-on-write semantics.
+			require 'base64'
+			require 'passenger/application'
+			require 'passenger/railz/framework_spawner'
+			require 'passenger/railz/application_spawner'
+			require 'passenger/rack/application_spawner'
+			require 'passenger/html_template'
+			require 'passenger/platform_info'
+			require 'passenger/exceptions'
+			
+			# Commonly used libraries.
+			['mysql', 'sqlite3'].each do |lib|
+				require lib
+			end
+		end
 	end
-
+	
 	# Spawn a RoR application When successful, an Application object will be
 	# returned, which represents the spawned RoR application.
 	#
-	# See ApplicationSpawner.new for an explanation of the +lower_privilege+
-	# and +lowest_user+ parameters.
+	# See Railz::ApplicationSpawner.new for an explanation of the +lower_privilege+,
+	# +lowest_user+ and +environment+ parameters.
 	#
-	# SpawnManager will internally cache the code of applications, in order to
-	# speed up future spawning attempts. This implies that, if you've
-	# changed the application's code, you must do one of these things:
+	# The +spawn_method+ argument may be one of "smart" or "conservative".
+	# When "smart" is specified (the default), SpawnManager will internally cache the
+	# code of applications, in order to speed up future spawning attempts. This implies
+	# that, if you've changed the application's code, you must do one of these things:
 	# - Restart this SpawnManager by calling AbstractServer#stop, then AbstractServer#start.
 	# - Reload the application by calling reload with the correct app_root argument.
+	# Caching however can be incompatible with some applications.
+	#
+	# The "conservative" spawning method does not involve any caching at all.
+	# Spawning will be slower, but is guaranteed to be compatible with all applications.
 	#
 	# Raises:
 	# - ArgumentError: +app_root+ doesn't appear to be a valid Ruby on Rails application root.
@@ -77,48 +100,27 @@ class SpawnManager < AbstractServer
 	# - AbstractServer::ServerError: One of the server processes exited unexpectedly.
 	# - FrameworkInitError: The Ruby on Rails framework that the application requires could not be loaded.
 	# - AppInitError: The application raised an exception or called exit() during startup.
-	def spawn_application(app_root, lower_privilege = true, lowest_user = "nobody")
-		framework_version = Application.detect_framework_version(app_root)
-		if framework_version == :vendor
-			vendor_path = normalize_path("#{app_root}/vendor/rails")
-			key = "vendor:#{vendor_path}"
-			create_spawner = proc do
-				FrameworkSpawner.new(:vendor => vendor_path)
-			end
-		elsif framework_version.nil?
-			app_root = normalize_path(app_root)
-			key = "app:#{app_root}"
-			create_spawner = proc do
-				ApplicationSpawner.new(app_root, lower_privilege, lowest_user)
+	def spawn_application(app_root, lower_privilege = true, lowest_user = "nobody",
+	                      environment = "production", spawn_method = "smart",
+	                      app_type = "rails")
+		if app_type == "rack"
+			if !defined?(Rack::ApplicationSpawner)
+				require 'passenger/rack/application_spawner'
 			end
+			return Rack::ApplicationSpawner.spawn_application(app_root,
+				lower_privilege, lowest_user, environment)
+		elsif app_type == "wsgi"
+			require 'passenger/wsgi/application_spawner'
+			return WSGI::ApplicationSpawner.spawn_application(app_root,
+				lower_privilege, lowest_user, environment)
 		else
-			key = "version:#{framework_version}"
-			create_spawner = proc do
-				FrameworkSpawner.new(:version => framework_version)
-			end
-		end
-		
-		spawner = nil
-		@lock.synchronize do
-			spawner = @spawners[key]
-			if !spawner
-				spawner = create_spawner.call
-				spawner.start
-				@spawners[key] = spawner
-			end
-			spawner.time = Time.now
-			begin
-				if spawner.is_a?(FrameworkSpawner)
-					return spawner.spawn_application(app_root, lower_privilege,
-						lowest_user)
-				else
-					return spawner.spawn_application
-				end
-			rescue AbstractServer::ServerError
-				spawner.stop
-				@spawners.delete(key)
-				raise
+			if !defined?(Railz::FrameworkSpawner)
+				require 'passenger/application'
+				require 'passenger/railz/framework_spawner'
+				require 'passenger/railz/application_spawner'
 			end
+			return spawn_rails_application(app_root, lower_privilege, lowest_user,
+				environment, spawn_method)
 		end
 	end
 	
@@ -148,7 +150,9 @@ class SpawnManager < AbstractServer
 				key = "app:#{app_root}"
 				spawner = @spawners[key]
 				if spawner
-					spawner.stop
+					if spawner.started?
+						spawner.stop
+					end
 					@spawners.delete(key)
 				end
 			end
@@ -169,18 +173,85 @@ class SpawnManager < AbstractServer
 		@cleaner_thread.join
 		@lock.synchronize do
 			@spawners.each_value do |spawner|
-				spawner.stop
+				if spawner.started?
+					spawner.stop
+				end
 			end
 			@spawners.clear
 		end
 	end
 
 private
-	def handle_spawn_application(app_root, lower_privilege, lowest_user)
+	def spawn_rails_application(app_root, lower_privilege, lowest_user,
+	                            environment, spawn_method)
+		if spawn_method == "smart"
+			spawner_must_be_started = true
+			framework_version = Application.detect_framework_version(app_root)
+			if framework_version == :vendor
+				vendor_path = normalize_path("#{app_root}/vendor/rails")
+				key = "vendor:#{vendor_path}"
+				create_spawner = proc do
+					Railz::FrameworkSpawner.new(:vendor => vendor_path)
+				end
+			elsif framework_version.nil?
+				app_root = normalize_path(app_root)
+				key = "app:#{app_root}"
+				create_spawner = proc do
+					Railz::ApplicationSpawner.new(app_root, lower_privilege,
+						lowest_user, environment)
+				end
+			else
+				key = "version:#{framework_version}"
+				create_spawner = proc do
+					Railz::FrameworkSpawner.new(:version => framework_version)
+				end
+			end
+		else
+			app_root = normalize_path(app_root)
+			key = "app:#{app_root}"
+			create_spawner = proc do
+				Railz::ApplicationSpawner.new(app_root, lower_privilege, lowest_user, environment)
+			end
+			spawner_must_be_started = false
+		end
+		
+		spawner = nil
+		@lock.synchronize do
+			spawner = @spawners[key]
+			if !spawner
+				spawner = create_spawner.call
+				if spawner_must_be_started
+					spawner.start
+				end
+				@spawners[key] = spawner
+			end
+			spawner.time = Time.now
+			begin
+				if spawner.is_a?(Railz::FrameworkSpawner)
+					return spawner.spawn_application(app_root, lower_privilege,
+						lowest_user, environment)
+				elsif spawner.started?
+					return spawner.spawn_application
+				else
+					return spawner.spawn_application!
+				end
+			rescue AbstractServer::ServerError
+				if spawner.started?
+					spawner.stop
+				end
+				@spawners.delete(key)
+				raise
+			end
+		end
+	end
+	
+	def handle_spawn_application(app_root, lower_privilege, lowest_user, environment,
+	                             spawn_method, app_type)
 		lower_privilege = lower_privilege == "true"
 		app = nil
 		begin
-			app = spawn_application(app_root, lower_privilege, lowest_user)
+			app = spawn_application(app_root, lower_privilege, lowest_user,
+				environment, spawn_method, app_type)
 		rescue ArgumentError => e
 			send_error_page(client, 'invalid_app_root', :error => e, :app_root => app_root)
 		rescue AbstractServer::ServerError => e
@@ -188,33 +259,39 @@ private
 		rescue VersionNotFound => e
 			send_error_page(client, 'version_not_found', :error => e, :app_root => app_root)
 		rescue AppInitError => e
-			if (defined?(Mysql::Error) && e.child_exception.is_a?(Mysql::Error)) ||
-			   (e.child_exception.is_a?(UnknownError) && e.child_exception.real_class_name =~ /^ActiveRecord/)
+			if database_error?(e)
 				send_error_page(client, 'database_error', :error => e,
-					:app_root => app_root)
-			elsif e.child_exception.is_a?(LoadError) ||
-			   (e.child_exception.is_a?(UnknownError) && e.child_exception.real_class_name == "MissingSourceFile")
+					:app_root => app_root, :app_name => app_name(app_type),
+					:app_type => app_type)
+			elsif load_error?(e)
 				# A source file failed to load, maybe because of a
 				# missing gem. If that's the case then the sysadmin
 				# will install probably the gem. So we clear RubyGems's
 				# cache so that it can detect new gems.
 				Gem.clear_paths
-				send_error_page(client, 'load_error', :error => e, :app_root => app_root)
+				send_error_page(client, 'load_error', :error => e, :app_root => app_root,
+					:app_name => app_name(app_type))
 			elsif e.child_exception.nil?
 				send_error_page(client, 'app_exited_during_initialization', :error => e,
-					:app_root => app_root)
+					:app_root => app_root, :app_name => app_name(app_type))
 			else
 				send_error_page(client, 'app_init_error', :error => e,
-					:app_root => app_root)
+					:app_root => app_root, :app_name => app_name(app_type))
 			end
 		rescue FrameworkInitError => e
 			send_error_page(client, 'framework_init_error', :error => e)
 		end
 		if app
-			client.write('ok')
-			client.write(app.pid, app.listen_socket_name, app.using_abstract_namespace?)
-			client.send_io(app.owner_pipe)
-			app.close
+			begin
+				client.write('ok')
+				client.write(app.pid, app.listen_socket_name, app.using_abstract_namespace?)
+				client.send_io(app.owner_pipe)
+			rescue Errno::EPIPE
+				# The Apache module may be interrupted during a spawn command,
+				# in which case it will close the connection. We ignore this error.
+			ensure
+				app.close
+			end
 		end
 	end
 	
@@ -231,13 +308,15 @@ private
 					current_time = Time.now
 					@spawners.keys.each do |key|
 						spawner = @spawners[key]
-						if spawner.is_a?(FrameworkSpawner)
+						if spawner.is_a?(Railz::FrameworkSpawner)
 							max_idle_time = FRAMEWORK_SPAWNER_MAX_IDLE_TIME
 						else
 							max_idle_time = APP_SPAWNER_MAX_IDLE_TIME
 						end
 						if current_time - spawner.time > max_idle_time
-							spawner.stop
+							if spawner.started?
+								spawner.stop
+							end
 							@spawners.delete(key)
 						end
 					end
@@ -247,11 +326,39 @@ private
 	end
 	
 	def send_error_page(channel, template_name, options = {})
-		options["enterprisey"] = File.exist?("#{File.dirname(__FILE__)}/../../enterprisey.txt")
+		require 'passenger/html_template' unless defined?(HTMLTemplate)
+		require 'passenger/platform_info' unless defined?(PlatformInfo)
+		options["enterprisey"] = File.exist?("#{File.dirname(__FILE__)}/../../enterprisey.txt") ||
+			File.exist?("/etc/passenger_enterprisey.txt")
 		data = HTMLTemplate.new(template_name, options).result
 		channel.write('error_page')
 		channel.write_scalar(data)
 	end
+	
+	def database_error?(e)
+		return ( defined?(Mysql::Error) && e.child_exception.is_a?(Mysql::Error) ) ||
+		       ( e.child_exception.is_a?(UnknownError) &&
+		           (
+		               e.child_exception.real_class_name =~ /^ActiveRecord/ ||
+		               e.child_exception.real_class_name =~ /^Mysql::/
+		           )
+		       )
+	end
+	
+	def load_error?(e)
+		return e.child_exception.is_a?(LoadError) || (
+		           e.child_exception.is_a?(UnknownError) &&
+		           e.child_exception.real_class_name == "MissingSourceFile"
+		)
+	end
+	
+	def app_name(app_type)
+		if app_type == "rails"
+			return "Ruby on Rails"
+		else
+			return "Ruby (Rack)"
+		end
+	end
 end
 
 end # module Passenger