colouringcode-passenger 0.1 → 0.2

data/ext/phusion_passenger/native_support.c

@@ -30,6 +30,7 @@
 #include <string.h>
 #include <unistd.h>
 #include <errno.h>
+#include <grp.h>
 #ifdef __OpenBSD__
 	// OpenBSD needs this for 'struct iovec'. Apparently it isn't
 	// always included by unistd.h and sys/types.h.
@@ -158,10 +159,14 @@ recv_fd(VALUE self, VALUE socket_fd) {
 	}
 	
 	control_header = CMSG_FIRSTHDR(&msg);
+	if (control_header == NULL) {
+		rb_raise(rb_eIOError, "No valid file descriptor received.");
+		return Qnil;
+	}
 	if (control_header->cmsg_len   != EXPECTED_CMSG_LEN
 	 || control_header->cmsg_level != SOL_SOCKET
 	 || control_header->cmsg_type  != SCM_RIGHTS) {
-		rb_sys_fail("No valid file descriptor received.");
+		rb_raise(rb_eIOError, "No valid file descriptor received.");
 		return Qnil;
 	}
 	#if defined(__APPLE__) || defined(__SOLARIS__) || defined(__arm__)
@@ -282,6 +287,29 @@ disable_stdio_buffering() {
 	return Qnil;
 }
 
+/**
+ * Ruby's implementations of initgroups, setgid and setuid are broken various ways,
+ * sigh...
+ * Ruby's setgid and setuid can't handle negative UIDs and initgroups is just broken.
+ * Work around it by using our own implementation.
+ */
+static VALUE
+switch_user(VALUE self, VALUE username, VALUE uid, VALUE gid) {
+	uid_t the_uid = NUM2LL(uid);
+	gid_t the_gid = NUM2LL(gid);
+
+	if (initgroups(RSTRING_PTR(username), the_gid) == -1) {
+		rb_sys_fail("initgroups");
+	}
+	if (setgid(the_gid) == -1) {
+		rb_sys_fail("setgid");
+	}
+	if (setuid(the_uid) == -1) {
+		rb_sys_fail("setuid");
+	}
+	return Qnil;
+}
+
 /***************************/
 
 void
@@ -302,6 +330,7 @@ Init_native_support() {
 	rb_define_singleton_method(mNativeSupport, "accept", f_accept, 1);
 	rb_define_singleton_method(mNativeSupport, "close_all_file_descriptors", close_all_file_descriptors, 1);
 	rb_define_singleton_method(mNativeSupport, "disable_stdio_buffering", disable_stdio_buffering, 0);
+	rb_define_singleton_method(mNativeSupport, "switch_user", switch_user, 3);
 	
 	/* The maximum length of a Unix socket path, including terminating null. */
 	rb_define_const(mNativeSupport, "UNIX_PATH_MAX", INT2NUM(sizeof(addr.sun_path)));

data/lib/phusion_passenger/constants.rb

@@ -24,7 +24,7 @@
 module PhusionPassenger
 	# Phusion Passenger version number.
 	# Don't forget to edit ext/common/Version.h too.
-	VERSION_STRING = '2.2.7'
+	VERSION_STRING = '2.2.12'
 	
 	DEFAULT_FRAMEWORK_SPAWNER_MAX_IDLE_TIME = 30 * 60
 	DEFAULT_APP_SPAWNER_MAX_IDLE_TIME       = 10 * 60

data/lib/phusion_passenger/dependencies.rb

@@ -357,6 +357,38 @@ module Dependencies # :nodoc: all
 		dep.install_instructions = "Please install RubyGems first, then run <b>#{PlatformInfo::GEM || "gem"} install rack</b>"
 	end
 	
+	OpenSSL_Dev = Dependency.new do |dep|
+		dep.name = "OpenSSL development headers"
+		dep.define_checker do |result|
+			source_file = '/tmp/passenger-openssl-check.c'
+			object_file = '/tmp/passenger-openssl-check.o'
+			begin
+				File.open(source_file, 'w') do |f|
+					f.write("#include <openssl/ssl.h>")
+				end
+				Dir.chdir(File.dirname(source_file)) do
+					if system("(gcc #{ENV['CFLAGS']} -c '#{source_file}') >/dev/null 2>/dev/null")
+						result.found
+					else
+						result.not_found
+					end
+				end
+			ensure
+				File.unlink(source_file) rescue nil
+				File.unlink(object_file) rescue nil
+			end
+		end
+		if RUBY_PLATFORM =~ /linux/
+			tags = PlatformInfo.linux_distro_tags
+			if tags.include?(:debian)
+				dep.install_command = "apt-get install libssl-dev"
+			elsif tags.include?(:redhat)
+				dep.install_command = "yum install openssl-devel"
+			end
+		end
+		dep.website = "http://www.openssl.org/"
+	end
+	
 	Zlib_Dev = Dependency.new do |dep|
 		dep.name = "Zlib development headers"
 		dep.define_checker do |result|

data/lib/phusion_passenger/message_channel.rb

@@ -193,8 +193,11 @@ class MessageChannel
 	#
 	# Might raise SystemCallError, IOError or SocketError when something
 	# goes wrong.
-	def recv_io
-		return @io.recv_io
+	def recv_io(klass = IO, negotiate = true)
+		write("pass IO") if negotiate
+		io = @io.recv_io(klass)
+		write("got IO") if negotiate
+		return io
 	end
 	
 	# Send an IO object (a file descriptor) over the channel. The other
@@ -204,7 +207,46 @@ class MessageChannel
 	# Might raise SystemCallError, IOError or SocketError when something
 	# goes wrong.
 	def send_io(io)
-		@io.send_io(io)
+		# We read a message before actually calling #send_io
+		# in order to prevent the other side from accidentally
+		# read()ing past the normal data and reading our file
+		# descriptor too.
+		#
+		# For example suppose that side A looks like this:
+		#
+		#   read(fd, buf, 1024)
+		#   read_io(fd)
+		#
+		# and side B:
+		#
+		#   write(fd, buf, 100)
+		#   send_io(fd_to_pass)
+		#
+		# If B completes both write() and send_io(), then A's read() call
+		# reads past the 100 bytes that B sent. On some platforms, like
+		# Linux, this will cause read_io() to fail. And it just so happens
+		# that Ruby's IO#read method slurps more than just the given amount
+		# of bytes.
+		result = read
+		if !result
+			raise EOFError, "End of stream"
+		elsif result != ["pass IO"]
+			raise IOError, "IO passing pre-negotiation header expected"
+		else
+			@io.send_io(io)
+			# Once you've sent the IO you expect to be able to close it on the
+			# sender's side, even if the other side hasn't read the IO yet.
+			# Not so: on some operating systems (I'm looking at you OS X) this
+			# can cause the receiving side to receive a bad file descriptor.
+			# The post negotiation protocol ensures that we block until the
+			# other side has really received the IO.
+			result = read
+			if !result
+				raise EOFError, "End of stream"
+			elsif result != ["got IO"]
+				raise IOError, "IO passing post-negotiation header expected"
+			end
+		end
 	end
 	
 	# Return the file descriptor of the underlying IO object.

data/lib/phusion_passenger/platform_info.rb

@@ -346,7 +346,7 @@ public
 			flags << '-DBOOST_HAS_STDINT_H -D_GLIBCPP__PTHREADS'
 		elsif RUBY_PLATFORM =~ /aix/
 			flags << '-DOXT_DISABLE_BACKTRACES'
-		elsif RUBY_PLATFORM =~ /(sparc-linux|arm-linux)/
+		elsif RUBY_PLATFORM =~ /(sparc-linux|arm-linux|sh4-linux)/
 			# http://code.google.com/p/phusion-passenger/issues/detail?id=200
 			# http://groups.google.com/group/phusion-passenger/t/6b904a962ee28e5c
 			flags << '-DBOOST_SP_USE_PTHREADS'

data/lib/phusion_passenger/rack/application_spawner.rb

@@ -21,10 +21,6 @@
 #  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'
-
 require 'socket'
 require 'phusion_passenger/application'
 require 'phusion_passenger/events'
@@ -90,6 +86,7 @@ private
 		app = nil
 		success = report_app_init_status(channel) do
 			ENV['RACK_ENV'] = options["environment"]
+			ENV['RAILS_ENV'] = options["environment"]
 			if options["base_uri"] && options["base_uri"] != "/"
 				ENV['RACK_BASE_URI'] = options["base_uri"]
 				ENV['RAILS_RELATIVE_URL_ROOT'] = options["base_uri"]
@@ -101,6 +98,11 @@ private
 			if options["lower_privilege"]
 				lower_privilege('config.ru', options["lowest_user"])
 			end
+			# Make sure RubyGems uses any new environment variable values
+			# that have been set now (e.g. $HOME, $GEM_HOME, etc) and that
+			# it is able to detect newly installed gems.
+			Gem.clear_paths
+			setup_bundler_support
 			app = load_rack_app
 		end
 		
@@ -137,6 +139,10 @@ private
 	end
 
 	def 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_code = ::File.read("config.ru")
 		eval("Rack::Builder.new {( #{rackup_code}\n )}.to_app", TOPLEVEL_BINDING, "config.ru")
 	end

data/lib/phusion_passenger/rack/request_handler.rb

@@ -22,11 +22,8 @@
 #  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'
+require 'phusion_passenger/utils/rewindable_input'
 
 module PhusionPassenger
 module Rack
@@ -64,7 +61,7 @@ class RequestHandler < AbstractRequestHandler
 protected
 	# Overrided method.
 	def process_request(env, input, output)
-		rewindable_input = ::Rack::RewindableInput.new(input)
+		rewindable_input = Utils::RewindableInput.new(input)
 		begin
 			env[RACK_VERSION]      = RACK_VERSION_VALUE
 			env[RACK_INPUT]        = rewindable_input

data/lib/phusion_passenger/railz/application_spawner.rb

@@ -161,6 +161,7 @@ class ApplicationSpawner < AbstractServer
 				channel = MessageChannel.new(b)
 				success = report_app_init_status(channel) do
 					ENV['RAILS_ENV'] = @environment
+					ENV['RACK_ENV'] = @environment
 					ENV['RAILS_RELATIVE_URL_ROOT'] = @base_uri
 					Dir.chdir(@app_root)
 					if @encoded_environment_variables
@@ -169,6 +170,11 @@ class ApplicationSpawner < AbstractServer
 					if @lower_privilege
 						lower_privilege('config/environment.rb', @lowest_user)
 					end
+					# Make sure RubyGems uses any new environment variable values
+					# that have been set now (e.g. $HOME, $GEM_HOME, etc) and that
+					# it is able to detect newly installed gems.
+					Gem.clear_paths
+					setup_bundler_support
 					
 					require File.expand_path('config/environment')
 					require 'dispatcher'
@@ -233,6 +239,7 @@ protected
 		report_app_init_status(client) do
 			$0 = "Passenger ApplicationSpawner: #{@app_root}"
 			ENV['RAILS_ENV'] = @environment
+			ENV['RACK_ENV'] = @environment
 			ENV['RAILS_RELATIVE_URL_ROOT'] = @base_uri
 			if defined?(RAILS_ENV)
 				Object.send(:remove_const, :RAILS_ENV)
@@ -245,6 +252,11 @@ protected
 			if @lower_privilege
 				lower_privilege('config/environment.rb', @lowest_user)
 			end
+			# Make sure RubyGems uses any new environment variable values
+			# that have been set now (e.g. $HOME, $GEM_HOME, etc) and that
+			# it is able to detect newly installed gems.
+			Gem.clear_paths
+			setup_bundler_support
 			preload_application
 		end
 	end
@@ -307,17 +319,28 @@ private
 		if !defined?(Dispatcher)
 			require 'dispatcher'
 		end
+		# Rails 2.2+ uses application_controller.rb while older versions use application.rb.
 		begin
 			require_dependency 'application_controller'
-		rescue LoadError
-			require_dependency 'application'
+		rescue LoadError => e
+			begin
+				require_dependency 'application'
+			rescue LoadError
+				# Considering that most apps these das are written in Rails
+				# 2.2+, if application.rb cannot be loaded either then it
+				# probably just means that application_controller.rb threw
+				# a LoadError. So we raise the original error here; if the
+				# app is based on Rails < 2.2 then the error will make less
+				# sense but we can only choose one or the other.
+				raise e
+			end
 		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)
+		if GC.copy_on_write_friendly? && !rails_will_preload_app_code?
 			['models','controllers','helpers'].each do |section|
 				Dir.glob("app/#{section}}/*.rb").each do |file|
 					require_dependency canonicalize_path(file)
@@ -325,11 +348,22 @@ private
 			end
 		end
 	end
+	
+	def rails_will_preload_app_code?
+		if defined?(Rails::Initializer)
+			return ::Rails::Initializer.method_defined?(:load_application_classes)
+		else
+			return defined?(::Rails3)
+		end
+	end
 
 	def handle_spawn_application
+		a, b = UNIXSocket.pair
 		safe_fork('application', true) do
 			begin
-				start_request_handler(client, true)
+				a.close
+				client.close
+				start_request_handler(MessageChannel.new(b), true)
 			rescue SignalException => e
 				if e.message != AbstractRequestHandler::HARD_TERMINATION_SIGNAL &&
 				   e.message != AbstractRequestHandler::SOFT_TERMINATION_SIGNAL
@@ -337,6 +371,17 @@ private
 				end
 			end
 		end
+		
+		b.close
+		worker_channel = MessageChannel.new(a)
+		info = worker_channel.read
+		owner_pipe = worker_channel.recv_io
+		client.write(*info)
+		client.send_io(owner_pipe)
+	ensure
+		a.close if a
+		b.close if b && !b.closed?
+		owner_pipe.close if owner_pipe
 	end
 	
 	# Initialize the request handler and enter its main loop.
@@ -348,11 +393,18 @@ private
 		$0 = "Rails: #{@app_root}"
 		reader, writer = IO.pipe
 		begin
-			# Re-establish connection if a connection was established
+			# Clear or 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
+			if defined?(::ActiveRecord::Base)
+				if ::ActiveRecord::Base.respond_to?(:clear_all_connections!)
+					::ActiveRecord::Base.clear_all_connections!
+				elsif ::ActiveRecord::Base.respond_to?(:clear_active_connections!)
+					::ActiveRecord::Base.clear_active_connections!
+				elsif ::ActiveRecord::Base.respond_to?(:connected?) &&
+				      ::ActiveRecord::Base.connected?
+					::ActiveRecord::Base.establish_connection
+				end
 			end
 			
 			reader.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)

data/lib/phusion_passenger/utils.rb

@@ -32,6 +32,7 @@ require 'etc'
 require 'fcntl'
 require 'tempfile'
 require 'stringio'
+require 'phusion_passenger/packaging'
 require 'phusion_passenger/exceptions'
 if !defined?(RUBY_ENGINE) || RUBY_ENGINE == "ruby"
 	require 'phusion_passenger/native_support'
@@ -163,6 +164,59 @@ protected
 		end
 	end
 	
+	def setup_bundler_support
+		# Rack::ApplicationSpawner depends on the 'rack' library, but the app
+		# might want us to use a bundled version instead of a
+		# gem/apt-get/yum/whatever-installed version. Therefore we must setup
+		# the correct load paths before requiring 'rack'.
+		#
+		# The most popular tool for bundling dependencies is Bundler. Bundler
+		# works as follows:
+		# - If the bundle is locked then a file .bundle/environment.rb exists
+		#   which will setup the load paths.
+		# - If the bundle is not locked then the load paths must be set up by
+		#   calling Bundler.setup.
+		# - Rails 3's boot.rb automatically loads .bundle/environment.rb or
+		#   calls Bundler.setup if that's not available.
+		# - Other Rack apps might not have a boot.rb but we still want to setup
+		#   Bundler.
+		#
+		# So the strategy is as follows:
+
+		# If the Bundler lock environment file exists then load that. If it
+		# exists then there's a 99.9% chance that loading it is the correct
+		# thing to do.
+		if File.exist?('.bundle/environment.rb')
+			require File.expand_path('.bundle/environment')
+
+		# If the Bundler environment file doesn't exist then there are two
+		# possibilities:
+		# 1. Bundler is not used, in which case we don't have to do anything.
+		# 2. Bundler *is* used, but the gems are not locked and we're supposed
+		#    to call Bundler.setup.
+		#
+		# The existence of Gemfile indicates whether (2) is true:
+		elsif File.exist?('Gemfile')
+			# In case of Rails 3, config/boot.rb already calls Bundler.setup.
+			# However older versions of Rails don't so loading boot.rb might
+			# not be the correct thing to do. To be on the safe side we
+			# call Bundler.setup ourselves; if this isn't the correct thing
+			# to do after all then there's always the load_path_setup_file
+			# option.
+			require 'rubygems'
+			require 'bundler'
+			Bundler.setup
+		end
+
+		# Bundler might remove Phusion Passenger from the load path in its zealous
+		# attempt to un-require RubyGems, so here we put Phusion Passenger back
+		# into the load path.
+		if $LOAD_PATH.first != LIBDIR
+			$LOAD_PATH.unshift(LIBDIR)
+			$LOAD_PATH.uniq!
+		end
+	end
+	
 	# 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
@@ -371,15 +425,7 @@ protected
 		if uid == 0
 			return false
 		else
-			# Some systems are broken. initgroups can fail because of
-			# all kinds of stupid reasons. So we ignore any errors
-			# raised by initgroups.
-			begin
-				Process.groups = Process.initgroups(username, gid)
-			rescue
-			end
-			Process::Sys.setgid(gid)
-			Process::Sys.setuid(uid)
+			NativeSupport.switch_user(username, uid, gid)
 			ENV['HOME'] = pw.dir
 			return true
 		end
@@ -538,8 +584,8 @@ class IO
 		# 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))
+		def recv_io(klass = IO)
+			return klass.for_fd(PhusionPassenger::NativeSupport.recv_fd(self.fileno))
 		end
 	end
 	
@@ -559,7 +605,6 @@ module Signal
 			result = Signal.list
 			result.delete("ALRM")
 			result.delete("VTALRM")
-			return result
 		when "jruby"
 			result = Signal.list
 			result.delete("QUIT")
@@ -567,12 +612,21 @@ module Signal
 			result.delete("FPE")
 			result.delete("KILL")
 			result.delete("SEGV")
-			result.delete("STOP")
 			result.delete("USR1")
-			return result
 		else
-			return Signal.list
+			result = Signal.list
 		end
+		
+		# Don't touch SIGCHLD no matter what! On OS X waitpid() will
+		# malfunction if SIGCHLD doesn't have a correct handler.
+		result.delete("CLD")
+		result.delete("CHLD")
+		
+		# Other stuff that we don't want to trap no matter which
+		# Ruby engine.
+		result.delete("STOP")
+		
+		return result
 	end
 end
 
@@ -582,7 +636,7 @@ end
 if RUBY_PLATFORM =~ /freebsd/ || RUBY_PLATFORM =~ /openbsd/ || (RUBY_PLATFORM =~ /darwin/ && RUBY_PLATFORM !~ /universal/)
 	require 'socket'
 	UNIXSocket.class_eval do
-		def recv_io
+		def recv_io(klass = IO)
 			super
 		end