colouringcode-passenger 0.1

data/lib/phusion_passenger/rack/request_handler.rb

@@ -0,0 +1,125 @@
+# encoding: binary
+#  Phusion Passenger - http://www.modrails.com/
+#  Copyright (c) 2008, 2009 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.
+
+rack_dir = File.expand_path(File.dirname(__FILE__) + "/../../../vendor/rack-1.0.0-git/lib")
+$LOAD_PATH.unshift(rack_dir) if !$LOAD_PATH.include?(rack_dir)
+require 'rack/rewindable_input'
+
+require 'phusion_passenger/abstract_request_handler'
+
+module PhusionPassenger
+module Rack
+
+# A request handler for Rack applications.
+class RequestHandler < AbstractRequestHandler
+	# Constants which exist to relieve Ruby's garbage collector.
+	RACK_VERSION       = "rack.version"        # :nodoc:
+	RACK_VERSION_VALUE = [1, 0]                # :nodoc:
+	RACK_INPUT         = "rack.input"          # :nodoc:
+	RACK_ERRORS        = "rack.errors"         # :nodoc:
+	RACK_MULTITHREAD   = "rack.multithread"    # :nodoc:
+	RACK_MULTIPROCESS  = "rack.multiprocess"   # :nodoc:
+	RACK_RUN_ONCE      = "rack.run_once"       # :nodoc:
+	RACK_URL_SCHEME	   = "rack.url_scheme"     # :nodoc:
+	SCRIPT_NAME        = "SCRIPT_NAME"         # :nodoc:
+	CONTENT_LENGTH      = "CONTENT_LENGTH"       # :nodoc:
+	CONTENT_TYPE        = "CONTENT_TYPE"         # :nodoc:
+	HTTP_CONTENT_LENGTH = "HTTP_CONTENT_LENGTH"  # :nodoc:
+	HTTP_CONTENT_TYPE = "HTTP_CONTENT_TYPE"      # :nodoc:
+	HTTPS          = "HTTPS"  # :nodoc:
+	HTTPS_DOWNCASE = "https"  # :nodoc:
+	HTTP           = "http"   # :nodoc:
+	YES            = "yes"    # :nodoc:
+	ON             = "on"     # :nodoc:
+	ONE            = "1"      # :nodoc:
+	CRLF           = "\r\n"   # :nodoc:
+
+	# +app+ is the Rack application object.
+	def initialize(owner_pipe, app, options = {})
+		super(owner_pipe, options)
+		@app = app
+	end
+
+protected
+	# Overrided method.
+	def process_request(env, input, output)
+		rewindable_input = ::Rack::RewindableInput.new(input)
+		begin
+			env[RACK_VERSION]      = RACK_VERSION_VALUE
+			env[RACK_INPUT]        = rewindable_input
+			env[RACK_ERRORS]       = STDERR
+			env[RACK_MULTITHREAD]  = false
+			env[RACK_MULTIPROCESS] = true
+			env[RACK_RUN_ONCE]     = false
+			
+			if env[HTTP_CONTENT_LENGTH] && env[CONTENT_LENGTH]
+				env.delete(HTTP_CONTENT_LENGTH)
+			elsif env[HTTP_CONTENT_LENGTH] && !env[CONTENT_LENGTH]
+				env[CONTENT_LENGTH] = env[HTTP_CONTENT_LENGTH]
+				env.delete(HTTP_CONTENT_LENGTH)
+			end
+			if env[HTTP_CONTENT_TYPE] && env[CONTENT_TYPE]
+				env.delete(HTTP_CONTENT_TYPE)
+			elsif env[HTTP_CONTENT_TYPE] && !env[CONTENT_TYPE]
+				env[CONTENT_TYPE] = env[HTTP_CONTENT_TYPE]
+				env.delete(HTTP_CONTENT_TYPE)
+			end
+			
+			if env[HTTPS] == YES || env[HTTPS] == ON || env[HTTPS] == ONE
+				env[RACK_URL_SCHEME] = HTTPS_DOWNCASE
+			else
+				env[RACK_URL_SCHEME] = HTTP
+			end
+			
+			status, headers, body = @app.call(env)
+			begin
+				output.write("Status: #{status.to_i}#{CRLF}")
+				output.write("X-Powered-By: #{PASSENGER_HEADER}#{CRLF}")
+				headers.each 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.is_a?(String)
+					output.write(body)
+				elsif body
+					body.each do |s|
+						output.write(s)
+					end
+				end
+			ensure
+				body.close if body.respond_to?(:close)
+			end
+		ensure
+			rewindable_input.close
+		end
+	end
+end
+
+end # module Rack
+end # module PhusionPassenger

data/lib/phusion_passenger/railz/application_spawner.rb

@@ -0,0 +1,386 @@
+#  Phusion Passenger - http://www.modrails.com/
+#  Copyright (c) 2008, 2009 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/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 PhusionPassenger
+module Railz
+
+# This class is capable of spawning instances of a single Ruby on Rails application.
+# It does so by preloading as much of the application's code as possible, then creating
+# instances of the application using what is already preloaded. This makes it spawning
+# application instances very fast, except for the first spawn.
+#
+# Use multiple instances of ApplicationSpawner if you need to spawn multiple different
+# Ruby on Rails applications.
+#
+# *Note*: ApplicationSpawner may only be started asynchronously with AbstractServer#start.
+# Starting it synchronously with AbstractServer#start_synchronously has not been tested.
+class ApplicationSpawner < AbstractServer
+	include Utils
+	
+	# This exception means that the ApplicationSpawner server process exited unexpectedly.
+	class Error < AbstractServer::ServerError
+	end
+	
+	# The user ID of the root user.
+	ROOT_UID = 0
+	# The group ID of the root user.
+	ROOT_GID = 0
+	
+	# 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 InvalidPath will be raised.
+	#
+	# 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.
+	#
+	# - +environment+:
+	#   Allows one to specify the RAILS_ENV environment to use.
+	#
+	# - +environment_variables+:
+	#   Environment variables which should be passed to the spawned application.
+	#   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+:
+	#   The base URI on which this application is deployed. It equals "/"
+	#   string if the application is deployed on the root URI. It must not
+	#   equal the empty string.
+	#
+	# - +print_exceptions+:
+	#   Whether exceptions that have occurred during application initialization
+	#   should be printed to STDERR. The default is true.
+	#
+	# All other options will be passed on to RequestHandler.
+	def initialize(app_root, options = {})
+		super()
+		@app_root = app_root
+		@canonicalized_app_root = canonicalize_path(app_root)
+		@options = sanitize_spawn_options(options)
+		@lower_privilege = @options["lower_privilege"]
+		@lowest_user     = @options["lowest_user"]
+		@environment     = @options["environment"]
+		@encoded_environment_variables = @options["environment_variables"]
+		@base_uri = @options["base_uri"] if @options["base_uri"] && @options["base_uri"] != "/"
+		@print_exceptions = @options["print_exceptions"]
+		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
+	
+	# Spawn an instance of the RoR application. When successful, an Application object
+	# will be returned, which represents the spawned RoR application.
+	#
+	# Raises:
+	# - AbstractServer::ServerNotStarted: The ApplicationSpawner server hasn't already been started.
+	# - ApplicationSpawner::Error: The ApplicationSpawner server exited unexpectedly.
+	def spawn_application
+		server.write("spawn_application")
+		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,
+			socket_type, owner_pipe)
+	rescue SystemCallError, IOError, SocketError => e
+		raise Error, "The application spawner server exited unexpectedly: #{e}"
+	end
+	
+	# Spawn an instance of the RoR application. When successful, an Application object
+	# will be returned, which represents the spawned RoR application.
+	#
+	# Unlike spawn_application, this method may be called even when the ApplicationSpawner
+	# server isn't started. This allows one to spawn a RoR application without preloading
+	# any source files.
+	#
+	# This method may only be called if no Rails framework has been loaded in the current
+	# Ruby VM.
+	#
+	# Raises:
+	# - AppInitError: The Ruby on Rails application raised an exception
+	#   or called exit() during startup.
+	# - SystemCallError, IOError, SocketError: Something went wrong.
+	def spawn_application!
+		a, b = UNIXSocket.pair
+		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
+					ENV['RAILS_RELATIVE_URL_ROOT'] = @base_uri
+					Dir.chdir(@app_root)
+					if @encoded_environment_variables
+						set_passed_environment_variables
+					end
+					if @lower_privilege
+						lower_privilege('config/environment.rb', @lowest_user)
+					end
+					
+					require File.expand_path('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
+		b.close
+		Process.waitpid(pid) rescue nil
+		
+		channel = MessageChannel.new(a)
+		unmarshal_and_raise_errors(channel, @print_exceptions)
+		
+		# No exception was raised, so spawning succeeded.
+		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,
+			socket_type, owner_pipe)
+	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
+			unmarshal_and_raise_errors(server, @print_exceptions)
+		rescue IOError, SystemCallError, SocketError => e
+			stop
+			raise Error, "The application spawner server exited unexpectedly: #{e}"
+		rescue
+			stop
+			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(client) do
+			$0 = "Passenger ApplicationSpawner: #{@app_root}"
+			ENV['RAILS_ENV'] = @environment
+			ENV['RAILS_RELATIVE_URL_ROOT'] = @base_uri
+			if defined?(RAILS_ENV)
+				Object.send(:remove_const, :RAILS_ENV)
+				Object.const_set(:RAILS_ENV, ENV['RAILS_ENV'])
+			end
+			Dir.chdir(@app_root)
+			if @encoded_environment_variables
+				set_passed_environment_variables
+			end
+			if @lower_privilege
+				lower_privilege('config/environment.rb', @lowest_user)
+			end
+			preload_application
+		end
+	end
+	
+private
+	def set_passed_environment_variables
+		env_vars_string = @encoded_environment_variables.unpack("m").first
+		# Prevent empty string as last item from b0rking the Hash[...] statement.
+		# See comment in Hooks.cpp (sendHeaders) for details.
+		env_vars_string << "_\0_"
+		env_vars = Hash[*env_vars_string.split("\0")]
+		env_vars.each_pair do |key, value|
+			ENV[key] = value
+		end
+	end
+	
+	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
+		if !defined?(Dispatcher)
+			require 'dispatcher'
+		end
+		begin
+			require_dependency 'application_controller'
+		rescue LoadError
+			require_dependency 'application'
+		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::Initializer.method_defined?(:load_application_classes)
+			['models','controllers','helpers'].each do |section|
+				Dir.glob("app/#{section}}/*.rb").each do |file|
+					require_dependency canonicalize_path(file)
+				end
+			end
+		end
+	end
+
+	def handle_spawn_application
+		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
+	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 start_request_handler(channel, forked)
+		$0 = "Rails: #{@app_root}"
+		reader, writer = IO.pipe
+		begin
+			# Re-establish connection if a connection was established
+			# in environment.rb. This prevents us from concurrently
+			# accessing the same MySQL connection handle.
+			if defined?(::ActiveRecord::Base) && ::ActiveRecord::Base.connected?
+				::ActiveRecord::Base.establish_connection
+			end
+			
+			reader.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+			
+			if Rails::VERSION::STRING >= '2.3.0'
+				rack_app = ::ActionController::Dispatcher.new
+				handler = Rack::RequestHandler.new(reader, rack_app, @options)
+			else
+				handler = RequestHandler.new(reader, @options)
+			end
+			
+			channel.write(Process.pid, handler.socket_name,
+				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 PhusionPassenger
+

data/lib/phusion_passenger/railz/cgi_fixed.rb

@@ -0,0 +1,68 @@
+# NOTE: This code is based on cgi_fixed.rb from Zed Shaw's scgi_rails
+# package, version 0.4.3. The license of this single file is as follows:
+#
+#  Copyright (c) 2004 Zed A. Shaw
+#  
+#  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.
+#
+# We also made some small local modifications.
+
+require 'cgi'
+
+module PhusionPassenger
+module Railz
+
+# Modifies CGI so that we can use it.  Main thing it does is expose
+# the stdinput and stdoutput so RequestHandler can connect them to
+# the right sources.  It also exposes the env_table so that RequestHandler
+# can hook the request parameters into the environment table.
+#
+# This is partially based on the FastCGI code, but much of the Ruby 1.6 
+# backwards compatibility is removed.
+class CGIFixed < ::CGI
+	public :env_table
+	
+	def initialize(params, input, output, *args)
+		@env_table = params
+		@args = *args
+		@input = input
+		@out = output
+		super(*args)
+	end
+	
+	def args
+		@args
+	end
+	
+	def env_table
+		@env_table
+	end
+	
+	def stdinput
+		@input
+	end
+	
+	def stdoutput
+		@out
+	end
+end
+
+end # module Railz
+end # module PhusionPassenger