passenger 2.0.6 → 2.1.2

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

@@ -14,9 +14,9 @@
 #  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
+require 'phusion_passenger/abstract_request_handler'
+require 'phusion_passenger/railz/cgi_fixed'
+module PhusionPassenger
 module Railz
 
 # A request handler for Ruby on Rails applications.
@@ -24,8 +24,8 @@ class RequestHandler < AbstractRequestHandler
 	NINJA_PATCHING_LOCK = Mutex.new
 	@@ninja_patched_action_controller = false
 	
-	def initialize(owner_pipe)
-		super(owner_pipe)
+	def initialize(owner_pipe, options = {})
+		super(owner_pipe, options)
 		NINJA_PATCHING_LOCK.synchronize do
 			ninja_patch_action_controller
 		end
@@ -58,4 +58,4 @@ private
 end
 
 end # module Railz
-end # module Passenger
+end # module PhusionPassenger

data/lib/{passenger → phusion_passenger}/spawn_manager.rb

@@ -16,10 +16,17 @@
 #  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_server'
-require 'passenger/constants'
-require 'passenger/utils'
-module Passenger
+require 'phusion_passenger/abstract_server'
+require 'phusion_passenger/abstract_server_collection'
+require 'phusion_passenger/constants'
+require 'phusion_passenger/utils'
+
+# Define a constant with a name that's unlikely to clash with anything the
+# application defines, so that they can detect whether they're running under
+# Phusion Passenger.
+IN_PHUSION_PASSENGER = true
+
+module PhusionPassenger
 
 # 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
@@ -30,7 +37,7 @@ module Passenger
 # tested. Don't forget to call cleanup after the server's main loop has
 # finished.
 #
-# == Ruby on Rails optimizations ===
+# == 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
@@ -47,27 +54,25 @@ class SpawnManager < AbstractServer
 	
 	def initialize
 		super()
-		@spawners = {}
-		@lock = Mutex.new
-		@cond = ConditionVariable.new
-		@cleaner_thread = Thread.new do
-			cleaner_thread_main
-		end
+		@spawners = AbstractServerCollection.new
 		define_message_handler(:spawn_application, :handle_spawn_application)
 		define_message_handler(:reload, :handle_reload)
 		define_signal_handler('SIGHUP', :reload)
 		
+		# Start garbage collector in order to free up some existing
+		# heap slots. This prevents the heap from growing unnecessarily
+		# during the startup phase.
 		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'
+			require 'phusion_passenger/application'
+			require 'phusion_passenger/railz/framework_spawner'
+			require 'phusion_passenger/railz/application_spawner'
+			require 'phusion_passenger/rack/application_spawner'
+			require 'phusion_passenger/html_template'
+			require 'phusion_passenger/platform_info'
+			require 'phusion_passenger/exceptions'
 			
 			# Commonly used libraries.
 			['mysql', 'sqlite3'].each do |lib|
@@ -80,51 +85,84 @@ class SpawnManager < AbstractServer
 		end
 	end
 	
-	# Spawn a RoR application When successful, an Application object will be
-	# returned, which represents the spawned RoR application.
-	#
-	# See Railz::ApplicationSpawner.new for an explanation of the +lower_privilege+,
-	# +lowest_user+ and +environment+ parameters.
+	# Spawn an application with the given spawn options. When successful, an
+	# Application object will be returned, which represents the spawned application.
+	# At least one option must be given: +app_root+. This is the application's root
+	# folder.
 	#
-	# 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.
+	# Other options are:
 	#
-	# The "conservative" spawning method does not involve any caching at all.
-	# Spawning will be slower, but is guaranteed to be compatible with all applications.
+	# ['lower_privilege', 'lowest_user' and 'environment']
+	#   See Railz::ApplicationSpawner.new for an explanation of these options.
+	# 
+	# ['app_type']
+	#   What kind of application is being spawned. Either "rails" (default), "rack" or "wsgi".
+	# 
+	# ['spawn_method']
+	#   May be one of "smart", "smart-lv2" or "conservative". When "smart" is specified,
+	#   SpawnManager will internally cache the code of Rails 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.
+	#   
+	#   "smart" caches the Rails framework code in a framework spawner server, and application
+	#   code in an application spawner server. Sometimes it is desirable to skip the
+	#   framework spawning and going directly for the application spawner instead. The
+	#   "smart-lv2" method allows you to do that.
+	#   
+	#   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.
+	#   
+	#   The default spawn method is "smart-lv2".
+	# 
+	# ['framework_spawner_timeout' and 'app_spawner_timeout']
+	#   These options allow you to specify the maximum idle timeout, in seconds, of the
+	#   framework spawner servers and application spawner servers that will be started under
+	#   the hood. These options are only used if +app_type+ equals "rails".
+	#   
+	#   A timeout of 0 means that the spawner server should never idle timeout. A timeout of
+	#   -1 means that the default timeout value should be used. The default value is -1.
 	#
-	# Raises:
-	# - ArgumentError: +app_root+ doesn't appear to be a valid Ruby on Rails application root.
+	# <b>Exceptions:</b>
+	# - InvalidPath: +app_root+ doesn't appear to be a valid Ruby on Rails application root.
 	# - VersionNotFound: The Ruby on Rails framework version that the given application requires
 	#   is not installed.
 	# - 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",
-	                      environment = "production", spawn_method = "smart",
-	                      app_type = "rails")
-		if app_type == "rack"
+	def spawn_application(options)
+		if !options["app_root"]
+			raise ArgumentError, "The 'app_root' option must be given."
+		end
+		options = sanitize_spawn_options(options)
+		
+		if options["app_type"] == "rails"
+			if !defined?(Railz::FrameworkSpawner)
+				require 'phusion_passenger/application'
+				require 'phusion_passenger/railz/framework_spawner'
+				require 'phusion_passenger/railz/application_spawner'
+			end
+			return spawn_rails_application(options)
+		elsif options["app_type"] == "rack"
 			if !defined?(Rack::ApplicationSpawner)
-				require 'passenger/rack/application_spawner'
+				require 'phusion_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)
+			return Rack::ApplicationSpawner.spawn_application(
+				options["app_root"], options
+			)
+		elsif options["app_type"] == "wsgi"
+			require 'phusion_passenger/wsgi/application_spawner'
+			return WSGI::ApplicationSpawner.spawn_application(
+				options["app_root"],
+				options["lower_privilege"],
+				options["lowest_user"],
+				options["environment"]
+			)
 		else
-			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)
+			raise ArgumentError, "Unknown 'app_type' value '#{options["app_type"]}'."
 		end
 	end
 	
@@ -145,23 +183,27 @@ class SpawnManager < AbstractServer
 		if app_root
 			begin
 				app_root = normalize_path(app_root)
-			rescue ArgumentError
+			rescue InvalidPath
 			end
 		end
-		@lock.synchronize do
+		@spawners.synchronize do
 			if app_root
 				# Delete associated ApplicationSpawner.
-				key = "app:#{app_root}"
-				spawner = @spawners[key]
-				if spawner
-					if spawner.started?
-						spawner.stop
+				@spawners.delete("app:#{app_root}")
+			else
+				# Delete all ApplicationSpawners.
+				keys_to_delete = []
+				@spawners.each_pair do |key, spawner|
+					if spawner.is_a?(Railz::ApplicationSpawner)
+						keys_to_delete << key
 					end
+				end
+				keys_to_delete.each do |key|
 					@spawners.delete(key)
 				end
 			end
-			@spawners.each_value do |spawner|
-				# Reload FrameworkSpawners.
+			@spawners.each do |spawner|
+				# Reload all FrameworkSpawners.
 				if spawner.respond_to?(:reload)
 					spawner.reload(app_root)
 				end
@@ -171,86 +213,77 @@ class SpawnManager < AbstractServer
 	
 	# Cleanup resources. Should be called when this SpawnManager is no longer needed.
 	def cleanup
-		@lock.synchronize do
-			@cond.signal
-		end
-		@cleaner_thread.join
-		@lock.synchronize do
-			@spawners.each_value do |spawner|
-				if spawner.started?
-					spawner.stop
-				end
-			end
-			@spawners.clear
-		end
+		@spawners.cleanup
 	end
 
 private
-	def spawn_rails_application(app_root, lower_privilege, lowest_user,
-	                            environment, spawn_method)
-		if spawn_method == "smart"
+	def spawn_rails_application(options)
+		spawn_method = options["spawn_method"]
+		app_root     = options["app_root"]
+		
+		if [nil, "", "smart", "smart-lv2"].include?(spawn_method)
 			spawner_must_be_started = true
-			framework_version = Application.detect_framework_version(app_root)
+			if spawn_method != "smart-lv2"
+				framework_version = Application.detect_framework_version(app_root)
+			end
 			if framework_version.nil? || framework_version == :vendor
 				app_root = normalize_path(app_root)
 				key = "app:#{app_root}"
 				create_spawner = proc do
-					Railz::ApplicationSpawner.new(app_root, lower_privilege,
-						lowest_user, environment)
+					Railz::ApplicationSpawner.new(app_root, options)
 				end
+				spawner_timeout = options["app_spawner_timeout"]
 			else
 				key = "version:#{framework_version}"
 				create_spawner = proc do
 					Railz::FrameworkSpawner.new(:version => framework_version)
 				end
+				spawner_timeout = options["framework_spawner_timeout"]
 			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)
+				Railz::ApplicationSpawner.new(app_root, options)
 			end
+			spawner_timeout = options["app_spawner_timeout"]
 			spawner_must_be_started = false
 		end
 		
-		spawner = nil
-		@lock.synchronize do
-			spawner = @spawners[key]
-			if !spawner
+		@spawners.synchronize do
+			spawner = @spawners.lookup_or_add(key) do
 				spawner = create_spawner.call
+				if spawner_timeout != -1
+					spawner.max_idle_time = spawner_timeout
+				end
 				if spawner_must_be_started
 					spawner.start
 				end
-				@spawners[key] = spawner
+				spawner
 			end
-			spawner.time = Time.now
 			begin
 				if spawner.is_a?(Railz::FrameworkSpawner)
-					return spawner.spawn_application(app_root, lower_privilege,
-						lowest_user, environment)
+					return spawner.spawn_application(app_root, options)
 				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"
+	def handle_spawn_application(*options)
+		options = sanitize_spawn_options(Hash[*options])
 		app = nil
+		app_root = options["app_root"]
+		app_type = options["app_type"]
 		begin
-			app = spawn_application(app_root, lower_privilege, lowest_user,
-				environment, spawn_method, app_type)
-		rescue ArgumentError => e
+			app = spawn_application(options)
+		rescue InvalidPath => e
 			send_error_page(client, 'invalid_app_root', :error => e, :app_root => app_root)
 		rescue AbstractServer::ServerError => e
 			send_error_page(client, 'general_error', :error => e)
@@ -269,7 +302,7 @@ private
 				Gem.clear_paths
 				send_error_page(client, 'load_error', :error => e, :app_root => app_root,
 					:app_name => app_name(app_type))
-			elsif e.child_exception.nil?
+			elsif e.child_exception.is_a?(SystemExit)
 				send_error_page(client, 'app_exited_during_initialization', :error => e,
 					:app_root => app_root, :app_name => app_name(app_type))
 			else
@@ -282,7 +315,8 @@ private
 		if app
 			begin
 				client.write('ok')
-				client.write(app.pid, app.listen_socket_name, app.using_abstract_namespace?)
+				client.write(app.pid, app.listen_socket_name,
+					app.listen_socket_type)
 				client.send_io(app.owner_pipe)
 			rescue Errno::EPIPE
 				# The Apache module may be interrupted during a spawn command,
@@ -297,35 +331,9 @@ private
 		reload(app_root)
 	end
 	
-	def cleaner_thread_main
-		@lock.synchronize do
-			while true
-				if @cond.timed_wait(@lock, SPAWNER_CLEAN_INTERVAL)
-					break
-				else
-					current_time = Time.now
-					@spawners.keys.each do |key|
-						spawner = @spawners[key]
-						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
-							if spawner.started?
-								spawner.stop
-							end
-							@spawners.delete(key)
-						end
-					end
-				end
-			end
-		end
-	end
-	
 	def send_error_page(channel, template_name, options = {})
-		require 'passenger/html_template' unless defined?(HTMLTemplate)
-		require 'passenger/platform_info' unless defined?(PlatformInfo)
+		require 'phusion_passenger/html_template' unless defined?(HTMLTemplate)
+		require 'phusion_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
@@ -359,4 +367,4 @@ private
 	end
 end
 
-end # module Passenger
+end # module PhusionPassenger

data/lib/phusion_passenger/templates/app_exited_during_initialization.html.erb

@@ -0,0 +1,38 @@
+<% layout 'error_layout', :title => "#{@app_name} application could not be started" do %>
+<h1 class="error_title"><%= @app_name %> application could not be started</h1>
+<div id="content">
+
+	The application has exited during startup (i.e. during the evaluation of
+	<tt>config/environment.rb</tt>).
+	<% if @error.stderr %>
+		The error message can be found below. To solve this problem, please
+		follow any instructions in the error message.
+	<% else %>
+		The error message may have been written to the web server's log file.
+		Please check the <b>web server's</b> log file (i.e. <em>not</em> the
+		(Rails) application's log file) to find out why the application
+		exited.
+		
+		<p>If that doesn't help, then please use the backtrace below to debug
+		the problem.</p>
+	<% end %>
+	
+	<dl>
+	<% if @error.stderr %>
+		<dt>Error message:</dt>
+		<dd><%=h @error.stderr %></dd>
+	<% end %>
+	
+	<dt>Application root:</dt>
+	<dd>
+		<tt class="filename"><%=h @app_root %></tt>
+	</dd>
+	
+	<dt>Backtrace:</dt>
+	<dd>
+		<%= backtrace_html_for(@error.child_exception) %>
+	</dd>
+	</dl>
+
+</div>
+<% end %>