passenger 2.0.6 → 2.1.2

data/lib/{passenger → phusion_passenger}/rack/application_spawner.rb

@@ -14,14 +14,17 @@
 #  with this program; if not, write to the Free Software Foundation, Inc.,
 #  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + "/../../../vendor/rack-0.9.1/lib"))
 require 'rack'
+
 require 'socket'
-require 'passenger/application'
-require 'passenger/message_channel'
-require 'passenger/abstract_request_handler'
-require 'passenger/utils'
-require 'passenger/rack/request_handler'
-module Passenger
+require 'phusion_passenger/application'
+require 'phusion_passenger/message_channel'
+require 'phusion_passenger/abstract_request_handler'
+require 'phusion_passenger/utils'
+require 'phusion_passenger/rack/request_handler'
+
+module PhusionPassenger
 module Rack
 
 # Class for spawning Rack applications.
@@ -41,14 +44,18 @@ class ApplicationSpawner
 	# - AppInitError: The Rack application raised an exception or called
 	#   exit() during startup.
 	# - SystemCallError, IOError, SocketError: Something went wrong.
-	def spawn_application(app_root, lower_privilege = true, lowest_user = "nobody", environment = "production")
+	def spawn_application(app_root, options = {})
+		options = sanitize_spawn_options(options)
+		
 		a, b = UNIXSocket.pair
-		# Double fork in order to prevent zombie processes.
-		pid = safe_fork(self.class.to_s) do
-			safe_fork(self.class.to_s) do
-				a.close
-				run(MessageChannel.new(b), app_root, lower_privilege, lowest_user, environment)
-			end
+		pid = safe_fork(self.class.to_s, true) do
+			a.close
+			
+			file_descriptors_to_leave_open = [0, 1, 2, b.fileno]
+			NativeSupport.close_all_file_descriptors(file_descriptors_to_leave_open)
+			close_all_io_objects_for_fds(file_descriptors_to_leave_open)
+			
+			run(MessageChannel.new(b), app_root, options)
 		end
 		b.close
 		Process.waitpid(pid) rescue nil
@@ -57,25 +64,25 @@ class ApplicationSpawner
 		unmarshal_and_raise_errors(channel, "rack")
 		
 		# No exception was raised, so spawning succeeded.
-		pid, socket_name, using_abstract_namespace = channel.read
+		pid, socket_name, socket_type = channel.read
 		if pid.nil?
 			raise IOError, "Connection closed"
 		end
 		owner_pipe = channel.recv_io
 		return Application.new(@app_root, pid, socket_name,
-			using_abstract_namespace == "true", owner_pipe)
+			socket_type, owner_pipe)
 	end
 
 private
 	
-	def run(channel, app_root, lower_privilege, lowest_user, environment)
+	def run(channel, app_root, options)
 		$0 = "Rack: #{app_root}"
 		app = nil
 		success = report_app_init_status(channel) do
-			ENV['RACK_ENV'] = environment
+			ENV['RACK_ENV'] = options["environment"]
 			Dir.chdir(app_root)
-			if lower_privilege
-				lower_privilege('config.ru', lowest_user)
+			if options["lower_privilege"]
+				lower_privilege('config.ru', options["lowest_user"])
 			end
 			app = load_rack_app
 		end
@@ -83,9 +90,9 @@ private
 		if success
 			reader, writer = IO.pipe
 			begin
-				handler = RequestHandler.new(reader, app)
+				handler = RequestHandler.new(reader, app, options)
 				channel.write(Process.pid, handler.socket_name,
-					handler.using_abstract_namespace?)
+					handler.socket_type)
 				channel.send_io(writer)
 				writer.close
 				channel.close
@@ -105,4 +112,4 @@ private
 end
 
 end # module Rack
-end # module Passenger
+end # module PhusionPassenger

data/lib/{passenger → phusion_passenger}/rack/request_handler.rb

@@ -14,8 +14,8 @@
 #  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'
-module Passenger
+require 'phusion_passenger/abstract_request_handler'
+module PhusionPassenger
 module Rack
 
 # A request handler for Rack applications.
@@ -40,8 +40,8 @@ class RequestHandler < AbstractRequestHandler
 	CRLF           = "\r\n"   # :nodoc:
 
 	# +app+ is the Rack application object.
-	def initialize(owner_pipe, app)
-		super(owner_pipe)
+	def initialize(owner_pipe, app, options = {})
+		super(owner_pipe, options)
 		@app = app
 	end
 
@@ -66,13 +66,18 @@ protected
 		begin
 			output.write("Status: #{status}#{CRLF}")
 			headers[X_POWERED_BY] = PASSENGER_HEADER
-			headers.each do |k, vs|
-				vs.each do |v|
-					output.write("#{k}: #{v}#{CRLF}")
+			headers.each_pair do |key, values|
+				if values.is_a?(String)
+					values = values.split("\n")
+				end
+				values.each do |value|
+					output.write("#{key}: #{value}#{CRLF}")
 				end
 			end
 			output.write(CRLF)
-			if body
+			if body.is_a?(String)
+				output.write(body)
+			elsif body
 				body.each do |s|
 					output.write(s)
 				end
@@ -84,4 +89,4 @@ protected
 end
 
 end # module Rack
-end # module Passenger
+end # module PhusionPassenger

data/lib/{passenger → phusion_passenger}/railz/application_spawner.rb

@@ -20,15 +20,17 @@ require 'rubygems'
 require 'socket'
 require 'etc'
 require 'fcntl'
-require 'passenger/application'
-require 'passenger/abstract_server'
-require 'passenger/application'
-require 'passenger/rack/request_handler'
-require 'passenger/railz/request_handler'
-require 'passenger/exceptions'
-require 'passenger/utils'
+require 'phusion_passenger/application'
+require 'phusion_passenger/abstract_server'
+require 'phusion_passenger/application'
+require 'phusion_passenger/constants'
+require 'phusion_passenger/events'
+require 'phusion_passenger/railz/request_handler'
+require 'phusion_passenger/rack/request_handler'
+require 'phusion_passenger/exceptions'
+require 'phusion_passenger/utils'
 
-module Passenger
+module PhusionPassenger
 module Railz
 
 # This class is capable of spawning instances of a single Ruby on Rails application.
@@ -53,41 +55,45 @@ class ApplicationSpawner < AbstractServer
 	# The group ID of the root user.
 	ROOT_GID = 0
 	
-	# An attribute, used internally. This should not be used outside Passenger.
-	attr_accessor :time
 	# The application root of this spawner.
 	attr_reader :app_root
 
 	# +app_root+ is the root directory of this application, i.e. the directory
 	# that contains 'app/', 'public/', etc. If given an invalid directory,
 	# or a directory that doesn't appear to be a Rails application root directory,
-	# then an ArgumentError will be raised.
+	# then an InvalidPath will be raised.
 	#
-	# If +lower_privilege+ is true, then ApplicationSpawner will attempt to
-	# switch to the user who owns the application's <tt>config/environment.rb</tt>,
-	# and to the default group of that user.
+	# Additional options are:
+	# - +lower_privilege+ and +lowest_user+:
+	#   If +lower_privilege+ is true, then ApplicationSpawner will attempt to
+	#   switch to the user who owns the application's <tt>config/environment.rb</tt>,
+	#   and to the default group of that user.
 	#
-	# If that user doesn't exist on the system, or if that user is root,
-	# then ApplicationSpawner will attempt to switch to the username given by
-	# +lowest_user+ (and to the default group of that user).
-	# If +lowest_user+ doesn't exist either, or if switching user failed
-	# (because the current process does not have the privilege to do so),
-	# then ApplicationSpawner will continue without reporting an error.
+	#   If that user doesn't exist on the system, or if that user is root,
+	#   then ApplicationSpawner will attempt to switch to the username given by
+	#   +lowest_user+ (and to the default group of that user).
+	#   If +lowest_user+ doesn't exist either, or if switching user failed
+	#   (because the current process does not have the privilege to do so),
+	#   then ApplicationSpawner will continue without reporting an error.
 	#
-	# The +environment+ argument allows one to specify the RAILS_ENV environment to use.
-	def initialize(app_root, lower_privilege = true, lowest_user = "nobody", environment = "production")
+	# - +environment+:
+	#   Allows one to specify the RAILS_ENV environment to use.
+	#
+	# All other options will be passed on to RequestHandler.
+	def initialize(app_root, options = {})
 		super()
 		begin
 			@app_root = normalize_path(app_root)
 		rescue SystemCallError => e
-			raise ArgumentError, e.message
-		rescue ArgumentError
+			raise InvalidPath, e.message
+		rescue InvalidPath
 			raise
 		end
-		@lower_privilege = lower_privilege
-		@lowest_user = lowest_user
-		@environment = environment
-		self.time = Time.now
+		@options = sanitize_spawn_options(options)
+		@lower_privilege = @options["lower_privilege"]
+		@lowest_user     = @options["lowest_user"]
+		@environment     = @options["environment"]
+		self.max_idle_time = DEFAULT_APP_SPAWNER_MAX_IDLE_TIME
 		assert_valid_app_root(@app_root)
 		define_message_handler(:spawn_application, :handle_spawn_application)
 	end
@@ -100,15 +106,15 @@ class ApplicationSpawner < AbstractServer
 	# - ApplicationSpawner::Error: The ApplicationSpawner server exited unexpectedly.
 	def spawn_application
 		server.write("spawn_application")
-		pid, socket_name, using_abstract_namespace = server.read
+		pid, socket_name, socket_type = server.read
 		if pid.nil?
 			raise IOError, "Connection closed"
 		end
 		owner_pipe = server.recv_io
 		return Application.new(@app_root, pid, socket_name,
-			using_abstract_namespace == "true", owner_pipe)
+			socket_type, owner_pipe)
 	rescue SystemCallError, IOError, SocketError => e
-		raise Error, "The application spawner server exited unexpectedly"
+		raise Error, "The application spawner server exited unexpectedly: #{e}"
 	end
 	
 	# Spawn an instance of the RoR application. When successful, an Application object
@@ -126,30 +132,37 @@ class ApplicationSpawner < AbstractServer
 	#   or called exit() during startup.
 	# - SystemCallError, IOError, SocketError: Something went wrong.
 	def spawn_application!
-		# Double fork to prevent zombie processes.
 		a, b = UNIXSocket.pair
-		pid = safe_fork(self.class.to_s) do
-			safe_fork('application') do
-				begin
-					a.close
-					channel = MessageChannel.new(b)
-					success = report_app_init_status(channel) do
-						ENV['RAILS_ENV'] = @environment
-						Dir.chdir(@app_root)
-						if @lower_privilege
-							lower_privilege('config/environment.rb', @lowest_user)
-						end
-						require 'config/environment'
-						require 'dispatcher'
-					end
-					if success
-						start_request_handler(channel)
-					end
-				rescue SignalException => e
-					if e.message != AbstractRequestHandler::HARD_TERMINATION_SIGNAL &&
-					   e.message != AbstractRequestHandler::SOFT_TERMINATION_SIGNAL
-						raise
+		pid = safe_fork('application', true) do
+			begin
+				a.close
+				
+				file_descriptors_to_leave_open = [0, 1, 2, b.fileno]
+				NativeSupport.close_all_file_descriptors(file_descriptors_to_leave_open)
+				close_all_io_objects_for_fds(file_descriptors_to_leave_open)
+				
+				channel = MessageChannel.new(b)
+				success = report_app_init_status(channel) do
+					ENV['RAILS_ENV'] = @environment
+					Dir.chdir(@app_root)
+					if @lower_privilege
+						lower_privilege('config/environment.rb', @lowest_user)
 					end
+
+					# require Rails' environment, using the same path as the original rails dispatcher,
+					# which normally does: require File.dirname(__FILE__) + "/../config/environment"
+					# thus avoiding the possibility of including the same file twice.
+					require 'public/../config/environment'
+
+					require 'dispatcher'
+				end
+				if success
+					start_request_handler(channel, false)
+				end
+			rescue SignalException => e
+				if e.message != AbstractRequestHandler::HARD_TERMINATION_SIGNAL &&
+				   e.message != AbstractRequestHandler::SOFT_TERMINATION_SIGNAL
+					raise
 				end
 			end
 		end
@@ -160,13 +173,13 @@ class ApplicationSpawner < AbstractServer
 		unmarshal_and_raise_errors(channel)
 		
 		# No exception was raised, so spawning succeeded.
-		pid, socket_name, using_abstract_namespace = channel.read
+		pid, socket_name, socket_type = channel.read
 		if pid.nil?
 			raise IOError, "Connection closed"
 		end
 		owner_pipe = channel.recv_io
 		return Application.new(@app_root, pid, socket_name,
-			using_abstract_namespace == "true", owner_pipe)
+			socket_type, owner_pipe)
 	end
 	
 	# Overrided from AbstractServer#start.
@@ -179,9 +192,9 @@ class ApplicationSpawner < AbstractServer
 		super
 		begin
 			unmarshal_and_raise_errors(server)
-		rescue IOError, SystemCallError, SocketError
+		rescue IOError, SystemCallError, SocketError => e
 			stop
-			raise Error, "The application spawner server exited unexpectedly"
+			raise Error, "The application spawner server exited unexpectedly: #{e}"
 		rescue
 			stop
 			raise
@@ -267,7 +280,12 @@ private
 		else
 			require_dependency 'application'
 		end
-		if GC.copy_on_write_friendly?
+		
+		# - No point in preloading the application sources if the garbage collector
+		#   isn't copy-on-write friendly.
+		# - Rails >= 2.2 already preloads application sources by default, so no need
+		#   to do that again.
+		if GC.copy_on_write_friendly? && !::Rails::Initializer.respond_to?(:load_application_classes)
 			Dir.glob('app/{models,controllers,helpers}/*.rb').each do |file|
 				require_dependency normalize_path(file)
 			end
@@ -275,25 +293,24 @@ private
 	end
 
 	def handle_spawn_application
-		# Double fork to prevent zombie processes.
-		pid = safe_fork(self.class.to_s) do
-			safe_fork('application') do
-				begin
-					start_request_handler(client)
-				rescue SignalException => e
-					if e.message != AbstractRequestHandler::HARD_TERMINATION_SIGNAL &&
-					   e.message != AbstractRequestHandler::SOFT_TERMINATION_SIGNAL
-						raise
-					end
+		safe_fork('application', true) do
+			begin
+				start_request_handler(client, true)
+			rescue SignalException => e
+				if e.message != AbstractRequestHandler::HARD_TERMINATION_SIGNAL &&
+				   e.message != AbstractRequestHandler::SOFT_TERMINATION_SIGNAL
+					raise
 				end
 			end
 		end
-		Process.waitpid(pid)
 	end
 	
 	# Initialize the request handler and enter its main loop.
 	# Spawn information will be sent back via _channel_.
-	def start_request_handler(channel)
+	# The _forked_ argument indicates whether a new process was forked off
+	# after loading environment.rb (i.e. whether smart spawning is being
+	# used).
+	def start_request_handler(channel, forked)
 		$0 = "Rails: #{@app_root}"
 		reader, writer = IO.pipe
 		begin
@@ -308,24 +325,27 @@ private
 			
 			if Rails::VERSION::STRING >= '2.3.0'
 				rack_app = ::ActionController::Dispatcher.new
-				handler = Rack::RequestHandler.new(reader, rack_app)
+				handler = Rack::RequestHandler.new(reader, rack_app, @options)
 			else
-				handler = RequestHandler.new(reader)
+				handler = RequestHandler.new(reader, @options)
 			end
 			
 			channel.write(Process.pid, handler.socket_name,
-				handler.using_abstract_namespace?)
+				handler.socket_type)
 			channel.send_io(writer)
 			writer.close
 			channel.close
+			
+			PhusionPassenger.call_event(:starting_worker_process, forked)
 			handler.main_loop
 		ensure
 			channel.close rescue nil
 			writer.close rescue nil
 			handler.cleanup rescue nil
+			PhusionPassenger.call_event(:stopping_worker_process)
 		end
 	end
 end
 
 end # module Railz
-end # module Passenger
+end # module PhusionPassenger

data/lib/{passenger → phusion_passenger}/railz/cgi_fixed.rb

@@ -26,7 +26,7 @@
 
 require 'cgi'
 
-module Passenger
+module PhusionPassenger
 module Railz
 
 # Modifies CGI so that we can use it.  Main thing it does is expose
@@ -65,4 +65,4 @@ class CGIFixed < ::CGI
 end
 
 end # module Railz
-end # module Passenger
+end # module PhusionPassenger

data/lib/{passenger → phusion_passenger}/railz/framework_spawner.rb

@@ -17,12 +17,13 @@
 #  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
+require 'phusion_passenger/abstract_server'
+require 'phusion_passenger/abstract_server_collection'
+require 'phusion_passenger/railz/application_spawner'
+require 'phusion_passenger/exceptions'
+require 'phusion_passenger/constants'
+require 'phusion_passenger/utils'
+module PhusionPassenger
 module Railz
 
 # This class is capable of spawning Ruby on Rails application instances
@@ -45,12 +46,9 @@ class FrameworkSpawner < AbstractServer
 	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:
+	# Valid options are:
 	# - <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
@@ -58,6 +56,8 @@ class FrameworkSpawner < AbstractServer
 	#
 	# It is not allowed to specify both +version+ and +vendor+.
 	#
+	# All other options will be passed on to ApplicationSpawner and RequestHandler.
+	#
 	# 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.
@@ -66,7 +66,7 @@ class FrameworkSpawner < AbstractServer
 			raise ArgumentError, "The 'options' argument not seem to be an options hash"
 		end
 		@version = options[:version]
-		@vendor = options[:vendor]
+		@vendor  = options[:vendor]
 		if !@version && !@vendor
 			raise ArgumentError, "Either the 'version' or the 'vendor' option must specified"
 		elsif @version && @vendor
@@ -74,6 +74,7 @@ class FrameworkSpawner < AbstractServer
 		end
 		
 		super()
+		self.max_idle_time = DEFAULT_FRAMEWORK_SPAWNER_MAX_IDLE_TIME
 		define_message_handler(:spawn_application, :handle_spawn_application)
 		define_message_handler(:reload, :handle_reload)
 	end
@@ -86,7 +87,12 @@ class FrameworkSpawner < AbstractServer
 	def start
 		super
 		begin
-			status = server.read[0]
+			result = server.read
+			if result.nil?
+				raise Error, "The framework spawner server exited unexpectedly."
+			else
+				status = result[0]
+			end
 			if status == 'exception'
 				child_exception = unmarshal_exception(server.read_scalar)
 				stop
@@ -111,8 +117,23 @@ class FrameworkSpawner < AbstractServer
 	# 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.
+	# The following options are allowed:
+	# - +lower_privilege+ and +lowest_user+:
+	#   If +lower_privilege+ is true, then ApplicationSpawner will attempt to
+	#   switch to the user who owns the application's <tt>config/environment.rb</tt>,
+	#   and to the default group of that user.
+	#
+	#   If that user doesn't exist on the system, or if that user is root,
+	#   then ApplicationSpawner will attempt to switch to the username given by
+	#   +lowest_user+ (and to the default group of that user).
+	#   If +lowest_user+ doesn't exist either, or if switching user failed
+	#   (because the current process does not have the privilege to do so),
+	#   then ApplicationSpawner will continue without reporting an error.
+	#
+	# - +environment+:
+	#   Allows one to specify the RAILS_ENV environment to use.
+	#
+	# All other options will be passed on to ApplicationSpawner and RequestHandler.
 	#
 	# FrameworkSpawner will internally cache the code of applications, in order to
 	# speed up future spawning attempts. This implies that, if you've changed
@@ -122,30 +143,37 @@ class FrameworkSpawner < AbstractServer
 	#
 	# 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.
+	# - InvalidAppRoot: +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")
+	def spawn_application(app_root, options = {})
 		app_root = normalize_path(app_root)
 		assert_valid_app_root(app_root)
+		options = sanitize_spawn_options(options)
+		options["app_root"] = app_root
+		
 		exception_to_propagate = nil
 		begin
-			server.write("spawn_application", app_root, lower_privilege, lowest_user, environment)
+			server.write("spawn_application", *options.to_a.flatten)
 			result = server.read
 			if result.nil?
 				raise IOError, "Connection closed"
 			end
 			if result[0] == 'exception'
-				raise unmarshal_exception(server.read_scalar)
+				e = unmarshal_exception(server.read_scalar)
+				if e.respond_to?(:child_exception) && e.child_exception
+					#print_exception(self.class.to_s, e.child_exception)
+				end
+				raise e
 			else
-				pid, listen_socket_name, using_abstract_namespace = server.read
+				pid, listen_socket_name, socket_type = 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)
+					socket_type, owner_pipe)
 			end
 		rescue SystemCallError, IOError, SocketError => e
 			raise Error, "The framework spawner server exited unexpectedly"
@@ -191,16 +219,7 @@ protected
 	# 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
+		@spawners = AbstractServerCollection.new
 		begin
 			preload_rails
 		rescue StandardError, ScriptError, NoMemoryError => e
@@ -213,13 +232,7 @@ protected
 	
 	# 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
+		@spawners.cleanup
 	end
 
 private
@@ -258,31 +271,36 @@ private
 		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
+	def handle_spawn_application(*options)
+		options = Hash[*options]
+		options["lower_privilege"]     = options["lower_privilege"] == "true"
+		options["app_spawner_timeout"] = options["app_spawner_timeout"].to_i
+		options["memory_limit"]        = options["memory_limit"].to_i
+		
+		app = nil
+		app_root = options["app_root"]
+		@spawners.synchronize do
+			begin
+				spawner = @spawners.lookup_or_add(app_root) do
+					spawner = ApplicationSpawner.new(app_root, options)
+					if options["app_spawner_timeout"] && options["app_spawner_timeout"] != -1
+						spawner.max_idle_time = options["app_spawner_timeout"]
 					end
-					return
+					spawner.start
+					spawner
 				end
-				@spawners[app_root] = spawner
+			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
-			spawner.time = Time.now
 			begin
 				app = spawner.spawn_application
 			rescue ApplicationSpawner::Error => e
@@ -292,53 +310,23 @@ private
 				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
+		client.write('success')
+		client.write(app.pid, app.listen_socket_name, app.listen_socket_type)
+		client.send_io(app.owner_pipe)
+		app.close
 	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
+		@spawners.synchronize do
+			if app_root
+				@spawners.delete(app_root)
 			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
+				@spawners.clear
 			end
 		end
 	end
 end
 
 end # module Railz
-end # module Passenger
+end # module PhusionPassenger