passenger 3.0.21 → 3.9.1.beta

data/lib/phusion_passenger/rack/application_spawner.rb

@@ -1,231 +0,0 @@
-# encoding: binary
-#  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 'socket'
-require 'phusion_passenger/app_process'
-require 'phusion_passenger/constants'
-require 'phusion_passenger/message_channel'
-require 'phusion_passenger/abstract_server'
-require 'phusion_passenger/abstract_request_handler'
-require 'phusion_passenger/debug_logging'
-require 'phusion_passenger/public_api'
-require 'phusion_passenger/utils'
-require 'phusion_passenger/native_support'
-require 'phusion_passenger/rack/request_handler'
-
-module PhusionPassenger
-module Rack
-
-# Spawning of Rack applications.
-class ApplicationSpawner < AbstractServer
-	include Utils
-	extend Utils
-	include DebugLogging
-	
-	# This exception means that the ApplicationSpawner server process exited unexpectedly.
-	class Error < AbstractServer::ServerError
-	end
-	
-	# Spawn an instance of the given Rack application. When successful, an
-	# AppProcess object will be returned, which represents the spawned
-	# application.
-	#
-	# Accepts the same options as SpawnManager#spawn_application.
-	#
-	# Raises:
-	# - AppInitError: The Rack 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(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)
-			
-			channel = MessageChannel.new(b)
-			app = nil
-			success = report_app_init_status(channel) do
-				prepare_app_process('config.ru', options)
-				app = load_rack_app
-				after_loading_app_code(options)
-			end
-			if success
-				start_request_handler(channel, app, false, options)
-			end
-		end
-		b.close
-		Process.waitpid(pid) rescue nil
-		
-		channel = MessageChannel.new(a)
-		unmarshal_and_raise_errors(channel, options["print_exceptions"], "rack")
-		
-		# 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 Rack application. When successful, an AppProcess object
-	# will be returned, which represents the spawned Rack 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 Rack 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: #{@options['app_group_name']}"
-			prepare_app_process('config.ru', @options)
-			@app = self.class.send(:load_rack_app)
-			after_loading_app_code(@options)
-		end
-	end
-
-private
-	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),
-					@app, 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
-
-	def self.start_request_handler(channel, app, forked, options)
-		app_root = options["app_root"]
-		$0 = "Rack: #{options['app_group_name']}"
-		reader, writer = IO.pipe
-		begin
-			reader.close_on_exec!
-			
-			handler = RequestHandler.new(reader, app, options)
-			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.load_rack_app
-		# Load Rack inside the spawned child process so that the spawn manager
-		# itself doesn't preload Rack. This is necessary because some broken
-		# Rails apps explicitly specify a Rack version as dependency.
-		require 'rack'
-		rackup_file = ENV["RACKUP_FILE"] || "config.ru"
-		rackup_code = ::File.open(rackup_file, 'rb') do |f|
-			f.read
-		end
-		eval("Rack::Builder.new {( #{rackup_code}\n )}.to_app", TOPLEVEL_BINDING, rackup_file)
-	end
-	private_class_method :load_rack_app
-end
-
-end # module Rack
-end # module PhusionPassenger

data/lib/phusion_passenger/spawn_manager.rb

@@ -1,359 +0,0 @@
-# encoding: binary
-#  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 'phusion_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
-# 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 ClassicRails::FrameworkSpawner to preload and cache
-# Ruby on Rails frameworks. ClassicRails::FrameworkSpawner, in turn, uses
-# ClassicRails::ApplicationSpawner to preload and cache application code.
-#
-# In case you're wondering why the namespace is "ClassicRails" and not "Rails":
-# it's to work around an obscure bug in ActiveSupport's Dispatcher.
-class SpawnManager < AbstractServer
-	include Utils
-	
-	def initialize(options = {})
-		super("", "")
-		@options = options
-		@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 'phusion_passenger/app_process'
-			require 'phusion_passenger/classic_rails/framework_spawner'
-			require 'phusion_passenger/classic_rails/application_spawner'
-			require 'phusion_passenger/rack/application_spawner'
-			require 'phusion_passenger/html_template'
-			require 'phusion_passenger/platform_info'
-			require 'phusion_passenger/exceptions'
-		end
-	end
-	
-	# Spawns an application with the given spawn options. When successful, an
-	# AppProcess object will be returned, which represents the spawned application
-	# process.
-	#
-	# Most options are explained in PoolOptions.h.
-	#
-	# Mandatory options:
-	# - 'app_root'
-	#
-	# Optional options:
-	# - 'app_type'
-	# - 'environment'
-	# - 'spawn_method'
-	# - 'user',
-	# - 'group'
-	# - 'default_user'
-	# - 'default_group'
-	# - 'framework_spawner_timeout'
-	# - 'app_spawner_timeout'
-	# - 'environment_variables': Environment variables which should be passed
-	#   to the spawned application process. This is NULL-seperated string of
-	#   key-value pairs, encoded in base64. The last byte in the unencoded
-	#   data must be a NULL.
-	# - 'base_uri'
-	# - 'print_exceptions'
-	#
-	# <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(options)
-		if !options["app_root"]
-			raise ArgumentError, "The 'app_root' option must be given."
-		end
-		options = sanitize_spawn_options(options)
-		
-		case options["app_type"]
-		when "rails"
-			if !defined?(ClassicRails::FrameworkSpawner)
-				require 'phusion_passenger/classic_rails/framework_spawner'
-				require 'phusion_passenger/classic_rails/application_spawner'
-			end
-			return spawn_rails_application(options)
-		when "rack"
-			if !defined?(Rack::ApplicationSpawner)
-				require 'phusion_passenger/rack/application_spawner'
-			end
-			return spawn_rack_application(options)
-		when "wsgi"
-			if !defined?(WSGI::ApplicationSpawner)
-				require 'phusion_passenger/wsgi/application_spawner'
-			end
-			return WSGI::ApplicationSpawner.spawn_application(options)
-		else
-			raise ArgumentError, "Unknown 'app_type' value '#{options["app_type"]}'."
-		end
-	end
-	
-	# 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. 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 AbstractServer::SpawnError if something went wrong.
-	def reload(app_group_name = nil)
-		@spawners.synchronize do
-			if app_group_name
-				# Stop and delete associated ApplicationSpawner.
-				@spawners.delete("app:#{app_group_name}")
-				# Propagate reload command to associated FrameworkSpawner.
-				@spawners.each do |spawner|
-					if spawner.respond_to?(:reload)
-						spawner.reload(app_group_name)
-					end
-				end
-			else
-				# Stop and delete all spawners.
-				@spawners.clear
-			end
-		end
-	end
-	
-	# Cleanup resources. Should be called when this SpawnManager is no longer needed.
-	def cleanup
-		@spawners.cleanup
-	end
-
-private
-	def spawn_rails_application(options)
-		app_root       = options["app_root"]
-		app_group_name = options["app_group_name"]
-		spawn_method   = options["spawn_method"]
-		spawner        = nil
-		create_spawner = nil
-		key            = nil
-		
-		case spawn_method
-		when nil, "", "smart", "smart-lv2"
-			if spawn_method != "smart-lv2"
-				framework_version = AppProcess.detect_framework_version(app_root)
-			end
-			if framework_version.nil? || framework_version == :vendor
-				key = "app:#{app_group_name}"
-				create_spawner = proc do
-					ClassicRails::ApplicationSpawner.new(@options.merge(options))
-				end
-				spawner_timeout = options["app_spawner_timeout"]
-			else
-				key = "version:#{framework_version}"
-				create_spawner = proc do
-					options["framework_version"] = framework_version
-					ClassicRails::FrameworkSpawner.new(@options.merge(options))
-				end
-				spawner_timeout = options["framework_spawner_timeout"]
-			end
-			
-			@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
-					spawner.start
-					spawner
-				end
-				begin
-					return spawner.spawn_application(options)
-				rescue AbstractServer::ServerError
-					@spawners.delete(key)
-					raise
-				end
-			end
-		else
-			return ClassicRails::ApplicationSpawner.spawn_application(
-				@options.merge(options))
-		end
-	end
-	
-	def spawn_rack_application(options)
-		app_group_name = options["app_group_name"]
-		spawn_method   = options["spawn_method"]
-		spawner        = nil
-		create_spawner = nil
-		key            = nil
-		
-		case spawn_method
-		when nil, "", "smart", "smart-lv2"
-			@spawners.synchronize do
-				key = "app:#{app_group_name}"
-				spawner = @spawners.lookup_or_add(key) do
-					spawner_timeout = options["app_spawner_timeout"]
-					spawner = Rack::ApplicationSpawner.new(
-						@options.merge(options))
-					if spawner_timeout != -1
-						spawner.max_idle_time = spawner_timeout
-					end
-					spawner.start
-					spawner
-				end
-				begin
-					return spawner.spawn_application(options)
-				rescue AbstractServer::ServerError
-					@spawners.delete(key)
-					raise
-				end
-			end
-		else
-			return Rack::ApplicationSpawner.spawn_application(
-				@options.merge(options))
-		end
-	end
-	
-	def handle_spawn_application(client, *options)
-		options     = sanitize_spawn_options(Hash[*options])
-		app_process = nil
-		app_root    = options["app_root"]
-		app_type    = options["app_type"]
-		begin
-			app_process = spawn_application(options)
-		rescue AbstractServer::ServerError => e
-			send_error_page(client, 'general_error', :error => e)
-		rescue VersionNotFound => e
-			send_error_page(client, 'version_not_found', :error => e, :app_root => app_root)
-		rescue AppInitError => e
-			if database_error?(e)
-				send_error_page(client, 'database_error', :error => e,
-					: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,
-					:app_name => app_name(app_type))
-			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
-				send_error_page(client, 'app_init_error', :error => e,
-					: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_process
-			begin
-				client.write('ok')
-				app_process.write_to_channel(client)
-			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_process.close
-			end
-		end
-	end
-	
-	def handle_reload(client, app_group_name)
-		reload(app_group_name)
-	end
-	
-	def send_error_page(channel, template_name, options = {})
-		require 'phusion_passenger/html_template' unless defined?(HTMLTemplate)
-		if !defined?(PlatformInfo)
-			require 'phusion_passenger/platform_info'
-			require 'phusion_passenger/platform_info/ruby'
-		end
-		options["enterprisey"] = File.exist?("#{SOURCE_ROOT}/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 PhusionPassenger