passenger 2.2.15 → 3.0.0.pre1

data/lib/phusion_passenger/classic_rails/application_spawner.rb

@@ -0,0 +1,344 @@
+#  Phusion Passenger - http://www.modrails.com/
+#  Copyright (c) 2010 Phusion
+#
+#  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
+#
+#  Permission is hereby granted, free of charge, to any person obtaining a copy
+#  of this software and associated documentation files (the "Software"), to deal
+#  in the Software without restriction, including without limitation the rights
+#  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+#  copies of the Software, and to permit persons to whom the Software is
+#  furnished to do so, subject to the following conditions:
+#
+#  The above copyright notice and this permission notice shall be included in
+#  all copies or substantial portions of the Software.
+#
+#  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+#  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+#  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+#  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+#  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+#  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+#  THE SOFTWARE.
+
+require 'rubygems'
+require 'socket'
+require 'etc'
+require 'fcntl'
+require 'phusion_passenger/abstract_server'
+require 'phusion_passenger/app_process'
+require 'phusion_passenger/constants'
+require 'phusion_passenger/debug_logging'
+require 'phusion_passenger/classic_rails/request_handler'
+require 'phusion_passenger/rack/request_handler'
+require 'phusion_passenger/public_api'
+require 'phusion_passenger/exceptions'
+require 'phusion_passenger/utils'
+
+module PhusionPassenger
+module ClassicRails
+
+# Spawning of Rails 1 and Rails 2 applications.
+#
+# ClassicRails::ApplicationSpawner can operate in two modes:
+# - Smart mode. In this mode, the Rails application's code is first preloaded into
+#   a temporary process, which can then further fork off application processes.
+#   Once the code has been preloaded, forking off application processes is very fast,
+#   and all the forked off application processes can share code memory with each other.
+#   To use this mode, create an ApplicationSpawner object, start it, and call
+#   #spawn_application on it.
+#   A single ApplicationSpawner object can only handle a single Rails application.
+# - Conservative mode. In this mode, a Rails app process is directly spawned
+#   without any preloading. This increases compatibility with applications. To use this
+#   mode, call ApplicationSpawner.spawn_application.
+class ApplicationSpawner < AbstractServer
+	include Utils
+	extend Utils
+	include DebugLogging
+	
+	# This exception means that the ApplicationSpawner server process exited unexpectedly.
+	class Error < AbstractServer::ServerError
+	end
+	
+	# The application root of this spawner.
+	attr_reader :app_root
+	
+	# Spawns an instance of a Rails application. When successful, an AppProcess object
+	# will be returned, which represents the spawned Rails application.
+	#
+	# This method spawns the application directly, without preloading its code.
+	# This method may only be called if no Rails framework has been loaded in the current
+	# Ruby VM.
+	#
+	# The "app_root" option must be given. All other options are passed to the request
+	# handler's constructor.
+	#
+	# Raises:
+	# - AppInitError: The Ruby on Rails application raised an exception
+	#   or called exit() during startup.
+	# - SystemCallError, IOError, SocketError: Something went wrong.
+	def self.spawn_application(options)
+		options = sanitize_spawn_options(options)
+		
+		a, b = UNIXSocket.pair
+		pid = safe_fork('application', 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)
+			
+			channel = MessageChannel.new(b)
+			success = report_app_init_status(channel) do
+				prepare_app_process('config/environment.rb', options)
+				require File.expand_path('config/environment')
+				require 'dispatcher'
+				after_loading_app_code(options)
+			end
+			if success
+				start_request_handler(channel, false, options)
+			end
+		end
+		b.close
+		Process.waitpid(pid) rescue nil
+		
+		channel = MessageChannel.new(a)
+		unmarshal_and_raise_errors(channel, options["print_exceptions"])
+		
+		# No exception was raised, so spawning succeeded.
+		return AppProcess.read_from_channel(channel)
+	end
+	
+	# The following options are accepted:
+	# - 'app_root'
+	#
+	# See SpawnManager#spawn_application for information about the options.
+	def initialize(options)
+		super()
+		@options          = sanitize_spawn_options(options)
+		@app_root         = @options["app_root"]
+		@canonicalized_app_root = canonicalize_path(@app_root)
+		self.max_idle_time = DEFAULT_APP_SPAWNER_MAX_IDLE_TIME
+		define_message_handler(:spawn_application, :handle_spawn_application)
+	end
+	
+	# Spawns an instance of the Rails application. When successful, an AppProcess object
+	# will be returned, which represents the spawned Rails application.
+	#
+	# +options+ will be passed to the request handler's constructor.
+	#
+	# Raises:
+	# - AbstractServer::ServerNotStarted: The ApplicationSpawner server hasn't already been started.
+	# - ApplicationSpawner::Error: The ApplicationSpawner server exited unexpectedly.
+	def spawn_application(options = {})
+		connect do |channel|
+			channel.write("spawn_application", *options.to_a.flatten)
+			return AppProcess.read_from_channel(channel)
+		end
+	rescue SystemCallError, IOError, SocketError => e
+		raise Error, "The application spawner server exited unexpectedly: #{e}"
+	end
+	
+	# Overrided from AbstractServer#start.
+	#
+	# May raise these additional exceptions:
+	# - AppInitError: The Ruby on Rails application raised an exception
+	#   or called exit() during startup.
+	# - ApplicationSpawner::Error: The ApplicationSpawner server exited unexpectedly.
+	def start
+		super
+		begin
+			channel = MessageChannel.new(@owner_socket)
+			unmarshal_and_raise_errors(channel, @options["print_exceptions"])
+		rescue IOError, SystemCallError, SocketError => e
+			stop if started?
+			raise Error, "The application spawner server exited unexpectedly: #{e}"
+		rescue
+			stop if started?
+			raise
+		end
+	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:
+		report_app_init_status(MessageChannel.new(@owner_socket)) do
+			$0 = "Passenger ApplicationSpawner: #{@app_root}"
+			prepare_app_process('config/environment.rb', @options)
+			if defined?(RAILS_ENV)
+				Object.send(:remove_const, :RAILS_ENV)
+				Object.const_set(:RAILS_ENV, ENV['RAILS_ENV'])
+			end
+			preload_application
+			after_loading_app_code(@options)
+		end
+	end
+	
+private
+	def preload_application
+		Object.const_set(:RAILS_ROOT, @canonicalized_app_root)
+		if defined?(::Rails::Initializer)
+			::Rails::Initializer.run(:set_load_path)
+			
+			# The Rails framework is loaded at the moment.
+			# environment.rb may set ENV['RAILS_ENV']. So we re-initialize
+			# RAILS_ENV in Rails::Initializer.load_environment.
+			::Rails::Initializer.class_eval do
+				def load_environment_with_passenger
+					using_default_log_path =
+						configuration.log_path ==
+						configuration.send(:default_log_path)
+					
+					if defined?(::RAILS_ENV)
+						Object.send(:remove_const, :RAILS_ENV)
+					end
+					Object.const_set(:RAILS_ENV, (ENV['RAILS_ENV'] || 'development').dup)
+					
+					if using_default_log_path
+						# We've changed the environment, so open the
+						# correct log file.
+						configuration.log_path = configuration.send(:default_log_path)
+					end
+					
+					load_environment_without_passenger
+				end
+				
+				alias_method :load_environment_without_passenger, :load_environment
+				alias_method :load_environment, :load_environment_with_passenger
+			end
+		end
+		if File.exist?('config/preinitializer.rb')
+			require File.expand_path('config/preinitializer')
+		end
+		require File.expand_path('config/environment')
+		if ActionController::Base.page_cache_directory.blank?
+			ActionController::Base.page_cache_directory = "#{RAILS_ROOT}/public"
+		end
+		if defined?(ActionController::Dispatcher) \
+		   && ActionController::Dispatcher.respond_to?(:error_file_path)
+			ActionController::Dispatcher.error_file_path = "#{RAILS_ROOT}/public"
+		end
+		
+		require 'rails/version' if !defined?(::Rails::VERSION)
+		if !defined?(Dispatcher)
+			begin
+				require 'dispatcher'
+			rescue LoadError
+				# Early versions of Rails 3 still had the dispatcher, but
+				# later versions disposed of it, in which case we'll need
+				# to use the application object.
+				raise if Rails::VERSION::MAJOR < 3
+			end
+		end
+		
+		# - 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_will_preload_app_code?
+			# Rails 2.2+ uses application_controller.rb while olde
+			# versions use application.rb.
+			require_dependency 'application'
+			['models','controllers','helpers'].each do |section|
+				Dir.glob("app/#{section}}/*.rb").each do |file|
+					require_dependency canonicalize_path(file)
+				end
+			end
+		end
+	end
+	
+	def rails_will_preload_app_code?
+		if defined?(Rails::Initializer)
+			return ::Rails::Initializer.method_defined?(:load_application_classes)
+		else
+			return Rails::VERSION::MAJOR >= 3
+		end
+	end
+
+	def handle_spawn_application(client, *options)
+		options = sanitize_spawn_options(Hash[*options])
+		a, b = UNIXSocket.pair
+		safe_fork('application', true) do
+			begin
+				a.close
+				client.close
+				options = @options.merge(options)
+				self.class.send(:start_request_handler, MessageChannel.new(b),
+					true, options)
+			rescue SignalException => e
+				if e.message != AbstractRequestHandler::HARD_TERMINATION_SIGNAL &&
+				   e.message != AbstractRequestHandler::SOFT_TERMINATION_SIGNAL
+					raise
+				end
+			end
+		end
+		
+		b.close
+		worker_channel = MessageChannel.new(a)
+		app_process = AppProcess.read_from_channel(worker_channel)
+		app_process.write_to_channel(client)
+	ensure
+		a.close if a
+		b.close if b && !b.closed?
+		app_process.close if app_process
+	end
+	
+	# Initialize the request handler and enter its main loop.
+	# Spawn information will be sent back via +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 self.start_request_handler(channel, forked, options)
+		app_root = options["app_root"]
+		$0 = "Rails: #{app_root}"
+		reader, writer = IO.pipe
+		begin
+			reader.close_on_exec!
+			
+			if Rails::VERSION::STRING >= '2.3.0'
+				rack_app = find_rack_app
+				handler = Rack::RequestHandler.new(reader, rack_app, options)
+			else
+				handler = RequestHandler.new(reader, options)
+			end
+			
+			app_process = AppProcess.new(app_root, Process.pid, writer,
+				handler.server_sockets)
+			app_process.write_to_channel(channel)
+			writer.close
+			channel.close
+			
+			before_handling_requests(forked, options)
+			handler.main_loop
+		ensure
+			channel.close rescue nil
+			writer.close rescue nil
+			handler.cleanup rescue nil
+			after_handling_requests
+		end
+	end
+	private_class_method :start_request_handler
+	
+	def self.find_rack_app
+		if Rails::VERSION::MAJOR >= 3
+			File.read("config/application.rb") =~ /^module (.+)$/
+			app_module = Object.const_get($1)
+			return app_module::Application
+		else
+			return ActionController::Dispatcher.new
+		end
+	end
+	private_class_method :find_rack_app
+end
+
+end # module ClassicRails
+end # module PhusionPassenger

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

@@ -27,7 +27,7 @@
 require 'cgi'
 
 module PhusionPassenger
-module Railz
+module ClassicRails
 
 # Modifies CGI so that we can use it.  Main thing it does is expose
 # the stdinput and stdoutput so RequestHandler can connect them to
@@ -64,5 +64,5 @@ class CGIFixed < ::CGI
 	end
 end
 
-end # module Railz
+end # module ClassicRails
 end # module PhusionPassenger

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

@@ -1,5 +1,5 @@
 #  Phusion Passenger - http://www.modrails.com/
-#  Copyright (c) 2008, 2009 Phusion
+#  Copyright (c) 2010 Phusion
 #
 #  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
 #
@@ -24,12 +24,13 @@
 require 'rubygems'
 require 'phusion_passenger/abstract_server'
 require 'phusion_passenger/abstract_server_collection'
-require 'phusion_passenger/railz/application_spawner'
+require 'phusion_passenger/app_process'
+require 'phusion_passenger/classic_rails/application_spawner'
 require 'phusion_passenger/exceptions'
 require 'phusion_passenger/constants'
 require 'phusion_passenger/utils'
 module PhusionPassenger
-module Railz
+module ClassicRails
 
 # This class is capable of spawning Ruby on Rails application instances
 # quickly. This is done by preloading the Ruby on Rails framework into memory,
@@ -53,16 +54,9 @@ class FrameworkSpawner < AbstractServer
 	
 	# Creates a new instance of FrameworkSpawner.
 	#
-	# Valid options are:
-	# - <tt>:version</tt>: The Ruby on Rails version to use. It is not checked whether
+	# Extra supported options:
+	# - <tt>framework_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".
-	# - <tt>:print_framework_loading_exceptions</tt>:
-	#   Whether exceptions that have occurred while loading the Ruby on Rails framework
-	#   should be printed to STDERR. The default is true.
-	#
-	# It is not allowed to specify both +version+ and +vendor+.
 	#
 	# All other options will be passed on to ApplicationSpawner and RequestHandler.
 	#
@@ -71,22 +65,20 @@ class FrameworkSpawner < AbstractServer
 	# 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"
+			raise ArgumentError, "The 'options' argument does not seem to be an options hash"
 		end
-		@version = options[:version]
-		@vendor  = options[:vendor]
-		if options.has_key?(:print_framework_loading_exceptions)
-			@print_framework_loading_exceptions = options[:print_framework_loading_exceptions]
+		@framework_version = options["framework_version"]
+		if options.has_key?("print_framework_loading_exceptions")
+			@print_framework_loading_exceptions = options["print_framework_loading_exceptions"]
 		else
 			@print_framework_loading_exceptions = true
 		end
-		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"
+		if !@framework_version
+			raise ArgumentError, "The 'framework_version' option must specified"
 		end
 		
 		super()
+		@options = options
 		self.max_idle_time = DEFAULT_FRAMEWORK_SPAWNER_MAX_IDLE_TIME
 		define_message_handler(:spawn_application, :handle_spawn_application)
 		define_message_handler(:reload, :handle_reload)
@@ -100,31 +92,30 @@ class FrameworkSpawner < AbstractServer
 	def start
 		super
 		begin
-			result = server.read
+			channel = MessageChannel.new(@owner_socket)
+			result = channel.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)
+				child_exception = unmarshal_exception(channel.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 }
+				message = "Could not load Ruby on Rails framework version #{@framework_version}: " <<
+					"#{child_exception.class} (#{child_exception.message})"
+				options = { :version => @framework_version }
 				if @print_framework_loading_exceptions
 					print_exception(self.class.to_s, child_exception)
 				end
 				raise FrameworkInitError.new(message, child_exception, options)
 			end
-		rescue IOError, SystemCallError, SocketError
-			stop
-			raise Error, "The framework spawner server exited unexpectedly"
+		rescue IOError, SystemCallError, SocketError => e
+			stop if started?
+			raise Error, "The framework spawner server exited unexpectedly: #{e}"
+		rescue
+			stop if started?
+			raise
 		end
 	end
 	
@@ -143,12 +134,11 @@ class FrameworkSpawner < AbstractServer
 	#
 	# Raises:
 	# - AbstractServer::ServerNotStarted: The FrameworkSpawner server hasn't already been started.
-	# - InvalidPath: +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, options = {})
-		assert_valid_app_root(app_root)
+	def spawn_application(options = {})
+		app_root = options["app_root"]
 		options = sanitize_spawn_options(options)
 		options["app_root"] = app_root
 		# No need for the ApplicationSpawner to print exceptions. All
@@ -158,36 +148,32 @@ class FrameworkSpawner < AbstractServer
 		options["print_exceptions"] = false
 		
 		begin
-			server.write("spawn_application", *options.to_a.flatten)
-			result = server.read
-			if result.nil?
-				raise IOError, "Connection closed"
-			end
-			if result[0] == 'exception'
-				e = unmarshal_exception(server.read_scalar)
-				if print_exceptions && e.respond_to?(:child_exception) && e.child_exception
-					print_exception(self.class.to_s, e.child_exception)
-				elsif print_exceptions
-					print_exception(self.class.to_s, e)
-				end
-				raise e
-			else
-				pid, listen_socket_name, socket_type = server.read
-				if pid.nil?
+			connect do |channel|
+				channel.write("spawn_application", *options.to_a.flatten)
+				result = channel.read
+				if result.nil?
 					raise IOError, "Connection closed"
 				end
-				owner_pipe = server.recv_io
-				return Application.new(app_root, pid, listen_socket_name,
-					socket_type, owner_pipe)
+				if result[0] == 'exception'
+					e = unmarshal_exception(channel.read_scalar)
+					if print_exceptions && e.respond_to?(:child_exception) && e.child_exception
+						print_exception(self.class.to_s, e.child_exception)
+					elsif print_exceptions
+						print_exception(self.class.to_s, e)
+					end
+					raise e
+				else
+					return AppProcess.read_from_channel(channel)
+				end
 			end
 		rescue SystemCallError, IOError, SocketError => e
-			raise Error, "The framework spawner server exited unexpectedly"
+			raise Error, "The framework spawner server exited unexpectedly: #{e}"
 		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.
+	# Remove the cached application instances at the given group name.
+	# If nil is specified as group name, then all cached application
+	# instances will be removed, no matter the group name.
 	#
 	# <b>Long description:</b>
 	# Application code might be cached in memory by a FrameworkSpawner. But
@@ -198,17 +184,17 @@ class FrameworkSpawner < AbstractServer
 	# 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", app_root)
+	def reload(app_group_name = nil)
+		connect do |channel|
+			if app_group_name.nil?
+				channel.write("reload")
+			else
+				channel.write("reload", app_group_name)
+			end
 		end
 	rescue SystemCallError, IOError, SocketError
-		raise Error, "The framework spawner server exited unexpectedly"
+		raise Error, "The framework spawner server exited unexpectedly: #{e}"
 	end
 
 protected
@@ -223,16 +209,17 @@ protected
 
 	# Overrided method.
 	def initialize_server # :nodoc:
-		$0 = "Passenger FrameworkSpawner: #{@version || @vendor}"
+		$0 = "Passenger FrameworkSpawner: #{@framework_version}"
 		@spawners = AbstractServerCollection.new
+		channel = MessageChannel.new(@owner_socket)
 		begin
 			preload_rails
 		rescue StandardError, ScriptError, NoMemoryError => e
-			client.write('exception')
-			client.write_scalar(marshal_exception(e))
+			channel.write('exception')
+			channel.write_scalar(marshal_exception(e))
 			return
 		end
-		client.write('success')
+		channel.write('success')
 	end
 	
 	# Overrided method.
@@ -243,17 +230,8 @@ protected
 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
+		gem 'rails', "=#{@framework_version}"
+		require 'initializer'
 		require 'active_support'
 		require 'active_record'
 		require 'action_controller'
@@ -276,15 +254,14 @@ private
 		Object.send(:remove_const, :RAILS_ROOT)
 	end
 
-	def handle_spawn_application(*options)
+	def handle_spawn_application(client, *options)
+		app_process = nil
 		options = sanitize_spawn_options(Hash[*options])
-		
-		app = nil
-		app_root = options["app_root"]
+		app_group_name = options["app_group_name"]
 		@spawners.synchronize do
 			begin
-				spawner = @spawners.lookup_or_add(app_root) do
-					spawner = ApplicationSpawner.new(app_root, options)
+				spawner = @spawners.lookup_or_add(app_group_name) do
+					spawner = ApplicationSpawner.new(@options.merge(options))
 					if options["app_spawner_timeout"] && options["app_spawner_timeout"] != -1
 						spawner.max_idle_time = options["app_spawner_timeout"]
 					end
@@ -304,25 +281,25 @@ private
 				return
 			end
 			begin
-				app = spawner.spawn_application
+				app_process = spawner.spawn_application(options)
 			rescue ApplicationSpawner::Error => e
 				spawner.stop
-				@spawners.delete(app_root)
+				@spawners.delete(app_group_name)
 				client.write('exception')
 				client.write_scalar(marshal_exception(e))
 				return
 			end
 		end
 		client.write('success')
-		client.write(app.pid, app.listen_socket_name, app.listen_socket_type)
-		client.send_io(app.owner_pipe)
-		app.close
+		app_process.write_to_channel(client)
+	ensure
+		app_process.close if app_process
 	end
 	
-	def handle_reload(app_root = nil)
+	def handle_reload(client, app_group_name = nil)
 		@spawners.synchronize do
-			if app_root
-				@spawners.delete(app_root)
+			if app_group_name
+				@spawners.delete(app_group_name)
 			else
 				@spawners.clear
 			end
@@ -330,5 +307,5 @@ private
 	end
 end
 
-end # module Railz
+end # module ClassicRails
 end # module PhusionPassenger