passenger 1.0.1

data/lib/passenger/request_handler.rb

@@ -0,0 +1,324 @@
+#  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 'socket'
+require 'base64'
+require 'passenger/message_channel'
+require 'passenger/cgi_fixed'
+require 'passenger/utils'
+module Passenger
+
+# The request handler's job is to process incoming HTTP requests using the
+# currently loaded Ruby on Rails application. HTTP requests are forwarded
+# to the request handler by the web server. HTTP responses generated by the
+# RoR application are forwarded to the web server, which, in turn, sends the
+# response back to the HTTP client.
+#
+#
+# == Design decisions
+#
+# Some design decisions are made because we want to decrease system
+# administrator maintenance overhead. These decisions are documented
+# in this section.
+#
+# === Abstract namespace Unix sockets
+#
+# RequestHandler listens on a Unix socket for incoming requests. If possible,
+# RequestHandler will try to create a Unix socket on the _abstract namespace_,
+# instead of on the filesystem. If the RoR application crashes (segfault),
+# or if it gets killed by SIGKILL, or if the system loses power, then there
+# will be no stale socket files left on the filesystem.
+# Unfortunately, abstract namespace Unix sockets are only supported by Linux.
+# On systems that do not support abstract namespace Unix sockets,
+# RequestHandler will automatically fallback to using regular Unix socket files.
+#
+# It is possible to force RequestHandler to use regular Unix socket files by
+# setting the environment variable PASSENGER_NO_ABSTRACT_NAMESPACE_SOCKETS
+# to 1.
+#
+# === Owner pipes
+#
+# Because only the web server communicates directly with a request handler,
+# we want the request handler to exit if the web server has also exited.
+# This is implemented by using a so-called _owner pipe_. The writable part
+# of the pipe will be owned by the web server. RequestHandler will
+# continuously check whether the other side of the pipe has been closed. If
+# so, then it knows that the web server has exited, and so the request handler
+# will exit as well. This works even if the web server gets killed by SIGKILL.
+#
+#
+# == Request format
+#
+# Incoming "HTTP requests" are not true HTTP requests, i.e. their binary
+# representation do not conform to RFC 2616. Instead, the request format
+# is based on CGI, and is similar to that of SCGI.
+#
+# The format consists of 3 parts:
+# - A 32-bit big-endian integer, containing the size of the transformed
+#   headers.
+# - The transformed HTTP headers.
+# - The verbatim (untransformed) HTTP request body.
+#
+# HTTP headers are transformed to a format that satisfies the following
+# grammar:
+#
+#  headers ::= header*
+#  header ::= name NUL value NUL
+#  name ::= notnull+
+#  value ::= notnull+
+#  notnull ::= "\x01" | "\x02" | "\x02" | ... | "\xFF"
+#  NUL = "\x00"
+#
+# The web server transforms the HTTP request to the aforementioned format,
+# and sends it to the request handler.
+class RequestHandler
+	# Signal which will cause the Rails application to exit immediately.
+	HARD_TERMINATION_SIGNAL = "SIGTERM"
+	# Signal which will cause the Rails application to exit as soon as it's done processing a request.
+	SOFT_TERMINATION_SIGNAL = "SIGUSR1"
+	BACKLOG_SIZE = 50
+	MAX_HEADER_SIZE = 128 * 1024
+	
+	# String constants which exist to relieve Ruby's garbage collector.
+	IGNORE = 'IGNORE' # :nodoc:
+	DEFAULT = 'DEFAULT' # :nodoc:
+	CONTENT_LENGTH = 'CONTENT_LENGTH' # :nodoc:
+	HTTP_CONTENT_LENGTH = 'HTTP_CONTENT_LENGTH' # :nodoc:
+	
+	NINJA_PATCHING_LOCK = Mutex.new
+	@@ninja_patched_action_controller = false
+	
+	File.read("#{File.dirname(__FILE__)}/../../Rakefile") =~ /^PACKAGE_VERSION = "(.*)"$/
+	PASSENGER_VERSION = $1
+	
+	# The name of the socket on which the request handler accepts
+	# new connections. This is either a Unix socket filename, or
+	# the name for an abstract namespace Unix socket.
+	#
+	# If +socket_name+ refers to an abstract namespace Unix socket,
+	# then the name does _not_ contain a leading null byte.
+	#
+	# See also using_abstract_namespace?
+	attr_reader :socket_name
+
+	# Create a new RequestHandler with the given owner pipe.
+	# +owner_pipe+ must be the readable part of a pipe IO object.
+	def initialize(owner_pipe)
+		if ENV['PASSENGER_NO_ABSTRACT_NAMESPACE_SOCKETS'].blank?
+			@using_abstract_namespace = create_unix_socket_on_abstract_namespace
+		else
+			@using_abstract_namespace = false
+		end
+		if !@using_abstract_namespace
+			create_unix_socket_on_filesystem
+		end
+		@owner_pipe = owner_pipe
+		@previous_signal_handlers = {}
+		
+		NINJA_PATCHING_LOCK.synchronize do
+			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"] = "Phusion Passenger (mod_rails) #{PASSENGER_VERSION}"
+						passenger_orig_perform_action(*whatever)
+					end
+				end
+			end
+		end
+	end
+	
+	# Clean up temporary stuff created by the request handler.
+	# This method should be called after the main loop has exited.
+	def cleanup
+		@socket.close rescue nil
+		@owner_pipe.close rescue nil
+		if !using_abstract_namespace?
+			File.unlink(@socket_name) rescue nil
+		end
+	end
+	
+	# Returns whether socket_name refers to an abstract namespace Unix socket.
+	def using_abstract_namespace?
+		return @using_abstract_namespace
+	end
+	
+	# Enter the request handler's main loop.
+	def main_loop
+		reset_signal_handlers
+		begin
+			done = false
+			while !done
+				client = accept_connection
+				if client.nil?
+					break
+				end
+				trap SOFT_TERMINATION_SIGNAL do
+					done = true
+				end
+				process_request(client)
+				trap SOFT_TERMINATION_SIGNAL, DEFAULT
+			end
+		rescue EOFError
+			# Exit main loop.
+		rescue Interrupt
+			# Exit main loop.
+		rescue SignalException => signal
+			if signal.message != HARD_TERMINATION_SIGNAL &&
+			   signal.message != SOFT_TERMINATION_SIGNAL
+				raise
+			end
+		ensure
+			revert_signal_handlers
+		end
+	end
+
+private
+	include Utils
+
+	def create_unix_socket_on_abstract_namespace
+		while true
+			begin
+				# I have no idea why, but using base64-encoded IDs
+				# don't pass the unit tests. I couldn't find the cause
+				# of the problem. The system supports base64-encoded
+				# names for abstract namespace unix sockets just fine.
+				@socket_name = generate_random_id(:hex)
+				@socket_name = @socket_name.slice(0, NativeSupport::UNIX_PATH_MAX - 2)
+				fd = NativeSupport.create_unix_socket("\x00#{socket_name}", BACKLOG_SIZE)
+				@socket = IO.new(fd)
+				@socket.instance_eval do
+					def accept
+						fd = NativeSupport.accept(fileno)
+						return IO.new(fd)
+					end
+				end
+				return true
+			rescue Errno::EADDRINUSE
+				# Do nothing, try again with another name.
+			rescue Errno::ENOENT
+				# Abstract namespace sockets not supported on this system.
+				return false
+			end
+		end
+	end
+	
+	def create_unix_socket_on_filesystem
+		done = false
+		while !done
+			begin
+				@socket_name = "/tmp/passenger.#{generate_random_id(:base64)}"
+				@socket_name = @socket_name.slice(0, NativeSupport::UNIX_PATH_MAX - 1)
+				@socket = UNIXServer.new(@socket_name)
+				File.chmod(0600, @socket_name)
+				done = true
+			rescue Errno::EADDRINUSE
+				# Do nothing, try again with another name.
+			end
+		end
+	end
+
+	def reset_signal_handlers
+		Signal.list.each_key do |signal|
+			begin
+				prev_handler = trap(signal, DEFAULT)
+				if prev_handler != DEFAULT
+					@previous_signal_handlers[signal] = prev_handler
+				end
+			rescue ArgumentError
+				# Signal cannot be trapped; ignore it.
+			end
+		end
+		prev_handler = trap('HUP', IGNORE)
+	end
+	
+	def revert_signal_handlers
+		@previous_signal_handlers.each_pair do |signal, handler|
+			trap(signal, handler)
+		end
+	end
+	
+	def accept_connection
+		ios = select([@socket, @owner_pipe])[0]
+		if ios.include?(@socket)
+			return @socket.accept
+		else
+			# The other end of the pipe has been closed.
+			# So we know all owning processes have quit.
+			return nil
+		end
+	end
+	
+	class ResponseSender # :nodoc:
+		def initialize(io)
+			@io = io
+		end
+		
+		def write(block)
+			@io.write(block)
+		end
+	end
+	
+	def process_request(socket)
+		channel = MessageChannel.new(socket)
+		headers_data = channel.read_scalar(MAX_HEADER_SIZE)
+		if headers_data.nil?
+			socket.close
+			return
+		end
+		
+		headers = Hash[*headers_data.split("\0")]
+		headers_data = nil
+		headers[CONTENT_LENGTH] = headers[HTTP_CONTENT_LENGTH]
+		
+		# TODO:
+		# Uploaded files are apparently put in /tmp, but not as temp files.
+		# That should be fixed.
+		
+		cgi = CGIFixed.new(headers, socket, ResponseSender.new(socket))
+		::Dispatcher.dispatch(cgi, ::ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS,
+			cgi.stdoutput)
+		socket.close
+	rescue IOError, SocketError, SystemCallError => e
+		print_exception("Passenger RequestHandler", e)
+	rescue SecurityError => e
+		STDERR.puts("*** Passenger RequestHandler: HTTP header size exceeded maximum.")
+		STDERR.flush
+		print_exception("Passenger RequestHandler", e)
+		socket.close rescue nil
+	end
+	
+	# Generate a long, cryptographically secure random ID string, which
+	# is also a valid filename.
+	def generate_random_id(method)
+		case method
+		when :base64
+			data = Base64.encode64(File.read("/dev/urandom", 64))
+			data.gsub!("\n", '')
+			data.gsub!("+", '')
+			data.gsub!("/", '')
+			data.gsub!(/==$/, '')
+		when :hex
+			data = File.read("/dev/urandom", 64).unpack('H*')[0]
+		end
+		return data
+	end
+end
+
+end # module Passenger

data/lib/passenger/simple_benchmarking.rb

@@ -0,0 +1,45 @@
+#  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.
+
+class Object # :nodoc:
+	@@benchmark_results = {}
+
+	def b!(name)
+		time1 = Time.now
+		begin
+			yield
+		ensure
+			time2 = Time.now
+			@@benchmark_results[name] = 0 unless @@benchmark_results.has_key?(name)
+			@@benchmark_results[name] += time2 - time1
+		end 
+	end
+
+	def benchmark_report(main = nil)
+		total = 0
+		if main.nil?
+			@@benchmark_results.each_value do |time|
+				total += time
+			end
+		else
+			total = @@benchmark_results[main]
+		end
+		@@benchmark_results.each_pair do |name, time|
+			printf "%-12s: %.4f (%.2f%%)\n", name, time, time / total * 100
+		end
+		printf "-- Total: %.4f\n", total
+	end
+end

data/lib/passenger/spawn_manager.rb

@@ -0,0 +1,251 @@
+#  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_server'
+require 'passenger/framework_spawner'
+require 'passenger/application'
+require 'passenger/message_channel'
+require 'passenger/html_template'
+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.
+#
+# *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.
+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
+		super()
+		@spawners = {}
+		@lock = Mutex.new
+		@cond = ConditionVariable.new
+		@cleaner_thread = Thread.new do
+			cleaner_thread_main
+		end
+		define_message_handler(:spawn_application, :handle_spawn_application)
+		define_message_handler(:reload, :handle_reload)
+		define_signal_handler('SIGHUP', :reload)
+	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.
+	#
+	# 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.
+	#
+	# Raises:
+	# - ArgumentError: +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")
+		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)
+			end
+		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
+		end
+		
+		spawner.time = Time.now
+		if spawner.is_a?(FrameworkSpawner)
+			return spawner.spawn_application(app_root, lower_privilege,
+				lowest_user)
+		else
+			return spawner.spawn_application
+		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. 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_root = nil)
+		if app_root
+			begin
+				app_root = normalize_path(app_root)
+			rescue ArgumentError
+			end
+		end
+		@lock.synchronize do
+			if app_root
+				# Delete associated ApplicationSpawner.
+				key = "app:#{app_root}"
+				spawner = @spawners[key]
+				if spawner
+					spawner.stop
+					@spawners.delete(key)
+				end
+			end
+			@spawners.each_value do |spawner|
+				# Reload FrameworkSpawners.
+				if spawner.respond_to?(:reload)
+					spawner.reload(app_root)
+				end
+			end
+		end
+	end
+	
+	# 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|
+				spawner.stop
+			end
+			@spawners.clear
+		end
+	end
+
+private
+	def handle_spawn_application(app_root, lower_privilege, lowest_user)
+		lower_privilege = lower_privilege == "true"
+		app = nil
+		begin
+			app = spawn_application(app_root, lower_privilege, lowest_user)
+		rescue ArgumentError => 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)
+		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/)
+				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")
+				# 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)
+			elsif e.child_exception.nil?
+				send_error_page(client, 'app_exited_during_initialization', :error => e,
+					:app_root => app_root)
+			else
+				send_error_page(client, 'app_init_error', :error => e,
+					:app_root => app_root)
+			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
+		end
+	end
+	
+	def handle_reload(app_root)
+		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?(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
+							@spawners.delete(key)
+						end
+					end
+				end
+			end
+		end
+	end
+	
+	def send_error_page(channel, template_name, options = {})
+		data = HTMLTemplate.new(template_name, options).result
+		channel.write('error_page')
+		channel.write_scalar(data)
+	end
+end
+
+end # module Passenger