passenger 2.0.6 → 2.1.2

data/lib/{passenger → phusion_passenger}/templates/deployment_example.txt.erb

@@ -6,7 +6,7 @@ to your Apache configuration file, and set its DocumentRoot to
 <b>
    <VirtualHost *:80>
       ServerName www.yourhost.com
-      DocumentRoot /somewhere/public
+      DocumentRoot /somewhere/public    # <-- be sure to point to 'public'!
    </VirtualHost>
 </b>
 And that's it! You may also want to check the Users Guide for security and

data/lib/{passenger → phusion_passenger}/templates/invalid_app_root.html.erb

@@ -2,7 +2,7 @@
 <h1 class="error_title">Cannot start Ruby on Rails application</h1>
 <div id="content">
 	
-	The directory <tt class="filename"><%=h @app_root %></tt>
+	The directory <tt class="filename">"<%=h @app_root %>"</tt>
 	does not appear to be a valid Ruby on Rails application root.
 	
 </div>

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

@@ -18,17 +18,19 @@
 
 require 'rubygems'
 require 'thread'
-if RUBY_PLATFORM != "java" && (RUBY_VERSION < "1.8.6" || (RUBY_VERSION == "1.8.6" && RUBY_PATCHLEVEL < 110))
+if (!defined?(RUBY_ENGINE) || RUBY_ENGINE == "ruby") && RUBY_VERSION < "1.8.7"
 	require 'fastthread'
 end
 require 'pathname'
 require 'etc'
-require 'passenger/exceptions'
-if RUBY_PLATFORM != "java"
-	require 'passenger/native_support'
+require 'fcntl'
+require 'tempfile'
+require 'phusion_passenger/exceptions'
+if !defined?(RUBY_ENGINE) || RUBY_ENGINE == "ruby"
+	require 'phusion_passenger/native_support'
 end
 
-module Passenger
+module PhusionPassenger
 
 # Utility functions.
 module Utils
@@ -38,32 +40,33 @@ protected
 	# and it correctly respects symbolic links.
 	#
 	# Raises SystemCallError if something went wrong. Raises ArgumentError
-	# if +path+ is nil.
+	# if +path+ is nil. Raises InvalidPath if +path+ does not appear
+	# to be a valid path.
 	def normalize_path(path)
 		raise ArgumentError, "The 'path' argument may not be nil" if path.nil?
 		return Pathname.new(path).realpath.to_s
 	rescue Errno::ENOENT => e
-		raise ArgumentError, e.message
+		raise InvalidAPath, e.message
 	end
 	
 	# Assert that +app_root+ is a valid Ruby on Rails application root.
-	# Raises ArgumentError if that is not the case.
+	# Raises InvalidPath if that is not the case.
 	def assert_valid_app_root(app_root)
 		assert_valid_directory(app_root)
 		assert_valid_file("#{app_root}/config/environment.rb")
 	end
 	
-	# Assert that +path+ is a directory. Raises +ArgumentError+ if it isn't.
+	# Assert that +path+ is a directory. Raises +InvalidPath+ if it isn't.
 	def assert_valid_directory(path)
 		if !File.directory?(path)
-			raise ArgumentError, "'#{path}' is not a valid directory."
+			raise InvalidPath, "'#{path}' is not a valid directory."
 		end
 	end
 	
-	# Assert that +path+ is a file. Raises +ArgumentError+ if it isn't.
+	# Assert that +path+ is a file. Raises +InvalidPath+ if it isn't.
 	def assert_valid_file(path)
 		if !File.file?(path)
-			raise ArgumentError, "'#{path}' is not a valid file."
+			raise InvalidPath, "'#{path}' is not a valid file."
 		end
 	end
 	
@@ -156,16 +159,37 @@ protected
 	# Fork a new process and run the given block inside the child process, just like
 	# fork(). Unlike fork(), this method is safe, i.e. there's no way for the child
 	# process to escape the block. Any uncaught exceptions in the child process will
-	# be printed to standard output, citing _current_location_ as the source.
-	def safe_fork(current_location)
-		return fork do
+	# be printed to standard output, citing +current_location+ as the source.
+	# Futhermore, the child process will exit by calling Kernel#exit!, thereby
+	# bypassing any at_exit or ensure blocks.
+	#
+	# If +double_fork+ is true, then the child process will fork and immediately exit.
+	# This technique can be used to avoid zombie processes, at the expense of not
+	# being able to waitpid() the second child.
+	def safe_fork(current_location = self.class, double_fork = false)
+		pid = fork
+		if pid.nil?
 			begin
-				yield
+				if double_fork
+					pid2 = fork
+					if pid2.nil?
+						yield
+					end
+				else
+					yield
+				end
 			rescue Exception => e
-				print_exception(current_location, e)
+				print_exception(current_location.to_s, e)
 			ensure
 				exit!
 			end
+		else
+			if double_fork
+				Process.waitpid(pid) rescue nil
+				return pid
+			else
+				return pid
+			end
 		end
 	end
 	
@@ -176,7 +200,25 @@ protected
 	# Exceptions are not propagated, except for SystemExit.
 	def report_app_init_status(channel)
 		begin
-			yield
+			old_global_stderr = $stderr
+			old_stderr = STDERR
+			stderr_output = ""
+			tempfile = Tempfile.new('passenger-stderr')
+			tempfile.unlink
+			Object.send(:remove_const, 'STDERR') rescue nil
+			Object.const_set('STDERR', tempfile)
+			begin
+				yield
+			ensure
+				Object.send(:remove_const, 'STDERR') rescue nil
+				Object.const_set('STDERR', old_stderr)
+				$stderr = old_global_stderr
+				if tempfile
+					tempfile.rewind
+					stderr_output = tempfile.read
+					tempfile.close rescue nil
+				end
+			end
 			channel.write('success')
 			return true
 		rescue StandardError, ScriptError, NoMemoryError => e
@@ -185,9 +227,12 @@ protected
 			end
 			channel.write('exception')
 			channel.write_scalar(marshal_exception(e))
+			channel.write_scalar(stderr_output)
 			return false
-		rescue SystemExit
+		rescue SystemExit => e
 			channel.write('exit')
+			channel.write_scalar(marshal_exception(e))
+			channel.write_scalar(stderr_output)
 			raise
 		end
 	end
@@ -208,15 +253,19 @@ protected
 		status = args[0]
 		if status == 'exception'
 			child_exception = unmarshal_exception(channel.read_scalar)
+			stderr = channel.read_scalar
 			#print_exception(self.class.to_s, child_exception)
 			raise AppInitError.new(
 				"Application '#{@app_root}' raised an exception: " <<
 				"#{child_exception.class} (#{child_exception.message})",
 				child_exception,
-				app_type)
+				app_type,
+				stderr.empty? ? nil : stderr)
 		elsif status == 'exit'
+			child_exception = unmarshal_exception(channel.read_scalar)
+			stderr = channel.read_scalar
 			raise AppInitError.new("Application '#{@app_root}' exited during startup",
-				nil, app_type)
+				child_exception, app_type, stderr.empty? ? nil : stderr)
 		end
 	end
 	
@@ -265,9 +314,40 @@ protected
 			return true
 		end
 	end
+	
+	def sanitize_spawn_options(options)
+		defaults = {
+			"lower_privilege" => true,
+			"lowest_user"     => "nobody",
+			"environment"     => "production",
+			"app_type"        => "rails",
+			"spawn_method"    => "smart-lv2",
+			"framework_spawner_timeout" => -1,
+			"app_spawner_timeout"       => -1
+		}
+		options = defaults.merge(options)
+		options["lower_privilege"]           = options["lower_privilege"].to_s == "true"
+		options["framework_spawner_timeout"] = options["framework_spawner_timeout"].to_i
+		options["app_spawner_timeout"]       = options["app_spawner_timeout"].to_i
+		return options
+	end
+	
+	# Returns the directory in which to store Phusion Passenger-specific
+	# temporary files. If +create+ is true, then this method creates the
+	# directory if it doesn't exist.
+	def passenger_tmpdir(create = true)
+		dir = ENV['PHUSION_PASSENGER_TMP']
+		if dir.nil? || dir.empty?
+			dir = Dir.tmpdir
+		end
+		if create && !File.exist?(dir)
+			system("mkdir", "-p", "-m", "u=rwxs,g=wx,o=wx", dir)
+		end
+		return dir
+	end
 end
 
-end # module Passenger
+end # module PhusionPassenger
 
 class Exception
 	def backtrace_string(current_location = nil)
@@ -287,15 +367,34 @@ class ConditionVariable
 	# amount of time. Returns true if this condition was signaled, false if a
 	# timeout occurred.
 	def timed_wait(mutex, secs)
-		require 'timeout' unless defined?(Timeout)
-		if secs > 0
-			Timeout.timeout(secs) do
-				wait(mutex)
+		if secs > 100000000
+			# NOTE: If one calls timeout() on FreeBSD 5 with an
+			# argument of more than 100000000, then MRI will become
+			# stuck in an infite loop, blocking all threads. It seems
+			# that MRI uses select() to implement sleeping.
+			# I think that a value of more than 100000000 overflows
+			# select()'s data structures, causing it to behave incorrectly.
+			# So we just make sure we can't sleep more than 100000000
+			# seconds.
+			secs = 100000000
+		end
+		if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
+			if secs > 0
+				return wait(mutex, secs)
+			else
+				return wait(mutex)
 			end
 		else
-			wait(mutex)
+			require 'timeout' unless defined?(Timeout)
+			if secs > 0
+				Timeout.timeout(secs) do
+					wait(mutex)
+				end
+			else
+				wait(mutex)
+			end
+			return true
 		end
-		return true
 	rescue Timeout::Error
 		return false
 	end
@@ -304,31 +403,99 @@ class ConditionVariable
 	# amount of time. Raises Timeout::Error if the timeout has elapsed.
 	def timed_wait!(mutex, secs)
 		require 'timeout' unless defined?(Timeout)
-		if secs > 0
-			Timeout.timeout(secs) do
+		if secs > 100000000
+			# See the corresponding note for timed_wait().
+			secs = 100000000
+		end
+		if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
+			if secs > 0
+				if !wait(mutex, secs)
+					raise Timeout::Error, "Timeout"
+				end
+			else
 				wait(mutex)
 			end
 		else
-			wait(mutex)
+			if secs > 0
+				Timeout.timeout(secs) do
+					wait(mutex)
+				end
+			else
+				wait(mutex)
+			end
 		end
+		return nil
 	end
 end
 
 class IO
-	# Send an IO object (i.e. a file descriptor) over this IO channel.
-	# This only works if this IO channel is a Unix socket.
-	#
-	# Raises SystemCallError if something went wrong.
-	def send_io(io)
-		Passenger::NativeSupport.send_fd(self.fileno, io.fileno)
+	if defined?(PhusionPassenger::NativeSupport)
+		# Send an IO object (i.e. a file descriptor) over this IO channel.
+		# This only works if this IO channel is a Unix socket.
+		#
+		# Raises SystemCallError if something went wrong.
+		def send_io(io)
+			PhusionPassenger::NativeSupport.send_fd(self.fileno, io.fileno)
+		end
+	
+		# Receive an IO object (i.e. a file descriptor) from this IO channel.
+		# This only works if this IO channel is a Unix socket.
+		#
+		# Raises SystemCallError if something went wrong.
+		def recv_io
+			return IO.new(PhusionPassenger::NativeSupport.recv_fd(self.fileno))
+		end
 	end
 	
-	# Receive an IO object (i.e. a file descriptor) from this IO channel.
-	# This only works if this IO channel is a Unix socket.
-	#
-	# Raises SystemCallError if something went wrong.
-	def recv_io
-		return IO.new(Passenger::NativeSupport.recv_fd(self.fileno))
+	def close_on_exec!
+		if defined?(Fcntl::F_SETFD)
+			fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+		end
+	end
+end
+
+module Signal
+	# Like Signal.list, but only returns signals that we can actually trap.
+	def self.list_trappable
+		ruby_engine = defined?(RUBY_ENGINE) ? RUBY_ENGINE : "mri"
+		case ruby_engine
+		when "mri"
+			if RUBY_VERSION >= '1.9.0'
+				return Signal.list
+			else
+				result = Signal.list
+				result.delete("ALRM")
+				return result
+			end
+		when "jruby"
+			result = Signal.list
+			result.delete("QUIT")
+			result.delete("ILL")
+			result.delete("FPE")
+			result.delete("KILL")
+			result.delete("SEGV")
+			result.delete("STOP")
+			result.delete("USR1")
+			return result
+		else
+			return Signal.list
+		end
+	end
+end
+
+# Ruby's implementation of UNIXSocket#recv_io and UNIXSocket#send_io
+# are broken on 64-bit FreeBSD 7. So we override them with our own
+# implementation.
+if RUBY_PLATFORM =~ /freebsd/
+	require 'socket'
+	UNIXSocket.class_eval do
+		def recv_io
+			super
+		end
+
+		def send_io(io)
+			super
+		end
 	end
 end
 
@@ -341,4 +508,3 @@ module GC
 		end
 	end
 end
-

data/lib/{passenger → phusion_passenger}/wsgi/application_spawner.rb

@@ -15,10 +15,10 @@
 #  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
 require 'socket'
-require 'passenger/application'
-require 'passenger/message_channel'
-require 'passenger/utils'
-module Passenger
+require 'phusion_passenger/application'
+require 'phusion_passenger/message_channel'
+require 'phusion_passenger/utils'
+module PhusionPassenger
 module WSGI
 
 # Class for spawning WSGI applications.
@@ -41,24 +41,26 @@ class ApplicationSpawner
 	# - SystemCallError, IOError, SocketError: Something went wrong.
 	def spawn_application(app_root, lower_privilege = true, lowest_user = "nobody", environment = "production")
 		a, b = UNIXSocket.pair
-		# Double fork in order to prevent zombie processes.
-		pid = safe_fork(self.class.to_s) do
-			safe_fork(self.class.to_s) do
-				a.close
-				run(MessageChannel.new(b), app_root, lower_privilege, lowest_user, environment)
-			end
+		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)
+			
+			run(MessageChannel.new(b), app_root, lower_privilege, lowest_user, environment)
 		end
 		b.close
 		Process.waitpid(pid) rescue nil
 		
 		channel = MessageChannel.new(a)
-		pid, socket_name, using_abstract_namespace = channel.read
+		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,
-			using_abstract_namespace == "true", owner_pipe)
+			socket_type, owner_pipe)
 	end
 
 private
@@ -70,11 +72,11 @@ private
 			lower_privilege('passenger_wsgi.py', lowest_user)
 		end
 		
-		socket_file = "/tmp/passenger_wsgi.#{Process.pid}.#{rand 10000000}"
+		socket_file = "#{passenger_tmpdir}/passenger_wsgi.#{Process.pid}.#{rand 10000000}"
 		server = UNIXServer.new(socket_file)
 		begin
 			reader, writer = IO.pipe
-			channel.write(Process.pid, socket_file, "false")
+			channel.write(Process.pid, socket_file, "unix")
 			channel.send_io(writer)
 			writer.close
 			channel.close
@@ -84,6 +86,7 @@ private
 			exec(REQUEST_HANDLER, socket_file, server.fileno.to_s,
 				reader.fileno.to_s)
 		rescue
+			server.close
 			File.unlink(socket_file)
 			raise
 		end
@@ -91,4 +94,4 @@ private
 end
 
 end # module WSGI
-end # module Passenger
+end # module PhusionPassenger