passenger 4.0.20 → 4.0.21

data/lib/phusion_passenger/platform_info/apache.rb

@@ -23,6 +23,8 @@
 
 require 'phusion_passenger/platform_info'
 require 'phusion_passenger/platform_info/compiler'
+require 'phusion_passenger/platform_info/operating_system'
+require 'phusion_passenger/platform_info/linux'
 
 module PhusionPassenger
 
@@ -98,6 +100,30 @@ module PlatformInfo
 	end
 	memoize :httpd_version
 
+	# The Apache executable's architectural bits. Returns 32 or 64,
+	# or nil if unable to detect.
+	def self.httpd_architecture_bits(options = nil)
+		if options
+			httpd = options[:httpd] || self.httpd(options)
+		else
+			httpd = self.httpd
+		end
+		if httpd
+			`#{httpd} -V` =~ %r{Architecture:(.*)}
+			text = $1
+			if text =~ /32/
+				return 32
+			elsif text =~ /64/
+				return 64
+			else
+				return nil
+			end
+		else
+			return nil
+		end
+	end
+	memoize :httpd_architecture_bits
+
 	# The Apache root directory.
 	def self.httpd_root(options = nil)
 		if info = httpd_V(options)
@@ -414,7 +440,7 @@ module PlatformInfo
 			apxs2_flags.gsub!(/-O\d? /, '')
 
 			# Remove flags not supported by GCC
-			if RUBY_PLATFORM =~ /solaris/ # TODO: Add support for people using SunStudio
+			if os_name =~ /solaris/ # TODO: Add support for people using SunStudio
 				# The big problem is Coolstack apxs includes a bunch of solaris -x directives.
 				options = apxs2_flags.split
 				options.reject! { |f| f =~ /^\-x/ }
@@ -423,11 +449,22 @@ module PlatformInfo
 				options.reject! { |f| f =~ /^\-mt/ }
 				apxs2_flags = options.join(' ')
 			end
+
+			if os_name == "linux" &&
+			   linux_distro_tags.include?(:redhat) &&
+			   apxs2 == "/usr/sbin/apxs" &&
+			   httpd_architecture_bits == 64
+				# The Apache package in CentOS 5 x86_64 is broken.
+				# 'apxs -q CFLAGS' contains directives for compiling
+				# the module as 32-bit, even though httpd itself
+				# is 64-bit. Fix this.
+				apxs2_flags.gsub!('-m32 -march=i386 -mtune=generic', '')
+			end
 			
 			apxs2_flags.strip!
 			flags << apxs2_flags
 		end
-		if !httpd.nil? && RUBY_PLATFORM =~ /darwin/
+		if !httpd.nil? && os_name == "macosx"
 			# The default Apache install on OS X is a universal binary.
 			# Figure out which architectures it's compiled for and do the same
 			# thing for mod_passenger. We use the 'file' utility to do this.
@@ -513,7 +550,7 @@ module PlatformInfo
 		return !try_compile("whether APR is needed for building Apache modules",
 			:c, "#include <apr.h>\n", apache2_module_cflags(false))
 	end
-	memoize :apr_config_needed_for_building_apache_modules?
+	memoize :apr_config_needed_for_building_apache_modules?, true
 
 private
 	def self.determine_apr_info
@@ -523,10 +560,10 @@ private
 			flags = `#{apr_config} --cppflags --includes`.strip
 			libs = `#{apr_config} --link-ld`.strip
 			flags.gsub!(/-O\d? /, '')
-			if RUBY_PLATFORM =~ /solaris/
+			if os_name =~ /solaris/
 				# Remove flags not supported by GCC
 				flags = flags.split(/ +/).reject{ |f| f =~ /^\-mt/ }.join(' ')
-			elsif RUBY_PLATFORM =~ /aix/
+			elsif os_name =~ /aix/
 				libs << " -Wl,-G -Wl,-brtl"
 			end
 			return [flags, libs]
@@ -545,7 +582,7 @@ private
 			return [flags, libs]
 		end
 	end
-	memoize :determine_apu_info
+	memoize :determine_apu_info, true
 	private_class_method :determine_apu_info
 
 	# Run `httpd -V` and return its output. On some systems, such as Ubuntu 13.10,

data/lib/phusion_passenger/platform_info/apache_detector.rb

@@ -76,6 +76,8 @@ class ApacheDetector
 		end
 	end
 
+	attr_reader :results
+
 	def initialize(output)
 		@output  = output
 		@results = []
@@ -175,25 +177,33 @@ class ApacheDetector
 			log "   <b>#{PhusionPassenger.bin_dir}/passenger-install-apache2-module</b>"
 			log ""
 			log "If you are sure that you have Apache installed, please read the documentation:"
-			log " * <b>#{PhusionPassenger.doc_dir}/Users guide Apache.html</b>, section"
+			log " * <b>#{PhusionPassenger.apache2_doc_path}</b>, section"
 			log "   section 'Installation' -> 'Customizing the compilation process' ->"
 			log "   'Forcing location of command line tools and dependencies'"
 			log " * Or visit the online version:"
-			log "   <b>http://www.modrails.com/documentation/Users%20guide%20Apache.html#_forcing_location_of_command_line_tools_and_dependencies</b>"
+			log "   <b>#{APACHE2_DOC_URL}#_forcing_location_of_command_line_tools_and_dependencies</b>"
 		elsif @results.size > 1
 			log "<yellow>WARNING: You have multiple Apache installations on your system!</yellow>"
 			log "You are strongly recommended to read this section of the documentation:"
-			log " * <b>#{PhusionPassenger.doc_dir}/Users guide Apache.html</b>, section"
+			log " * <b>#{PhusionPassenger.apache2_doc_path}</b>, section"
 			log "   section 'Installation' -> 'Customizing the compilation process' ->"
 			log "   'Forcing location of command line tools and dependencies'"
 			log " * Or visit the online version:"
-			log "   <b>http://www.modrails.com/documentation/Users%20guide%20Apache.html#_forcing_location_of_command_line_tools_and_dependencies</b>"
+			log "   <b>#{APACHE2_DOC_URL}#_forcing_location_of_command_line_tools_and_dependencies</b>"
 		end
 	end
 
+	def result_for(apxs2)
+		return @results.find { |r| r.apxs2 == apxs2 }
+	end
+
 private
 	def log(message)
-		@output.puts(Utils::AnsiColors.ansi_colorize(message))
+		if @output.tty?
+			@output.puts(Utils::AnsiColors.ansi_colorize(message))
+		else
+			@output.puts(Utils::AnsiColors.strip_color_tags(message))
+		end
 	end
 
 	# On Ubuntu, /usr/bin/apxs2 is a symlink to /usr/bin/apxs. We're only

data/lib/phusion_passenger/platform_info/compiler.rb

@@ -40,6 +40,18 @@ private
 	end
 	private_class_method :detect_language_extension
 
+	def self.detect_compiler_type_name(language)
+		case language
+		when :c
+			return "C"
+		when :cxx
+			return "C++"
+		else
+			raise ArgumentError, "Unsupported language #{language.inspect}"
+		end
+	end
+	private_class_method :detect_compiler_type_name
+
 	def self.create_compiler_command(language, flags1, flags2, link = false)
 		case language
 		when :c
@@ -94,17 +106,40 @@ private
 		elsif result
 			log("Check suceeded")
 			if capture_output
-				return { :output => output }
+				return { :result => true, :output => output }
 			else
 				return true
 			end
 		else
 			log("Check failed with exit status #{$?.exitstatus}")
-			return false
+			if capture_output == :always
+				return { :result => false, :output => output }
+			else
+				return false
+			end
 		end
 	end
 	private_class_method :run_compiler
 
+	def self.cc_or_cxx_supports_feliminate_unused_debug?(language)
+		ext = detect_language_extension(language)
+		compiler_type_name = detect_compiler_type_name(language)
+		create_temp_file("passenger-compile-check.#{ext}") do |filename, f|
+			f.close
+			begin
+				command = create_compiler_command(language,
+					"-c '#{filename}' -o '#{filename}.o'",
+					'-feliminate-unused-debug-symbols -feliminate-unused-debug-types')
+				result = run_compiler("Checking for #{compiler_type_name} compiler '--feliminate-unused-debug-{symbols,types}' support",
+					command, filename, '', true)
+				return result && result[:output].empty?
+			ensure
+				File.unlink("#{filename}.o") rescue nil
+			end
+		end
+	end
+	private_class_method :cc_or_cxx_supports_feliminate_unused_debug?
+
 public
 	def self.cc
 		return string_env('CC', default_cc)
@@ -135,6 +170,11 @@ public
 		end
 	end
 
+	def self.cc_is_gcc?
+		`#{cc} -v 2>&1` =~ /gcc version/
+	end
+	memoize :cc_is_gcc?
+
 	def self.cc_is_clang?
 		`#{cc} --version 2>&1` =~ /clang version/
 	end
@@ -150,6 +190,11 @@ public
 	end
 	memoize :cc_is_sun_studio?
 
+	def self.cxx_is_sun_studio?
+		`#{cxx} -V 2>&1` =~ /Sun C/ || `#{cc} -flags 2>&1` =~ /Sun C/
+	end
+	memoize :cxx_is_sun_studio?
+
 
 	# Looks for the given C or C++ header. This works by invoking the compiler and
 	# searching in the compiler's header search path. Returns its full filename,
@@ -254,68 +299,140 @@ public
 			:c, '', "-arch #{arch}")
 	end
 	
-	def self.compiler_supports_visibility_flag?
-		return false if RUBY_PLATFORM =~ /aix/
+	def self.cc_supports_visibility_flag?
+		return false if os_name =~ /aix/
 		return try_compile("Checking for C compiler '-fvisibility' support",
 			:c, '', '-fvisibility=hidden')
 	end
-	memoize :compiler_supports_visibility_flag?, true
+	memoize :cc_supports_visibility_flag?, true
+
+	def self.cxx_supports_visibility_flag?
+		return false if os_name =~ /aix/
+		return try_compile("Checking for C++ compiler '-fvisibility' support",
+			:cxx, '', '-fvisibility=hidden')
+	end
+	memoize :cxx_supports_visibility_flag?, true
 	
-	def self.compiler_supports_wno_attributes_flag?
+	def self.cc_supports_wno_attributes_flag?
 		return try_compile("Checking for C compiler '-Wno-attributes' support",
 			:c, '', '-Wno-attributes')
 	end
-	memoize :compiler_supports_wno_attributes_flag?, true
+	memoize :cc_supports_wno_attributes_flag?, true
 
-	def self.compiler_supports_wno_missing_field_initializers_flag?
+	def self.cxx_supports_wno_attributes_flag?
+		return try_compile("Checking for C++ compiler '-Wno-attributes' support",
+			:cxx, '', '-Wno-attributes')
+	end
+	memoize :cxx_supports_wno_attributes_flag?, true
+
+	def self.cc_supports_wno_missing_field_initializers_flag?
 		return try_compile("Checking for C compiler '-Wno-missing-field-initializers' support",
 			:c, '', '-Wno-missing-field-initializers')
 	end
-	memoize :compiler_supports_wno_missing_field_initializers_flag?, true
+	memoize :cc_supports_wno_missing_field_initializers_flag?, true
+
+	def self.cxx_supports_wno_missing_field_initializers_flag?
+		return try_compile("Checking for C++ compiler '-Wno-missing-field-initializers' support",
+			:cxx, '', '-Wno-missing-field-initializers')
+	end
+	memoize :cxx_supports_wno_missing_field_initializers_flag?, true
 	
-	def self.compiler_supports_no_tls_direct_seg_refs_option?
+	def self.cc_supports_no_tls_direct_seg_refs_option?
 		return try_compile("Checking for C compiler '-mno-tls-direct-seg-refs' support",
 			:c, '', '-mno-tls-direct-seg-refs')
 	end
-	memoize :compiler_supports_no_tls_direct_seg_refs_option?, true
+	memoize :cc_supports_no_tls_direct_seg_refs_option?, true
 
-	def self.compiler_supports_wno_ambiguous_member_template?
-		return try_compile("Checking for C compiler '-Wno-ambiguous-member-template' support",
-			:c, '', '-Wno-ambiguous-member-template')
+	def self.cxx_supports_no_tls_direct_seg_refs_option?
+		return try_compile("Checking for C++ compiler '-mno-tls-direct-seg-refs' support",
+			:cxx, '', '-mno-tls-direct-seg-refs')
 	end
-	memoize :compiler_supports_wno_ambiguous_member_template?, true
+	memoize :cxx_supports_no_tls_direct_seg_refs_option?, true
+
+	def self.compiler_supports_wno_ambiguous_member_template?
+		result = try_compile("Checking for C++ compiler '-Wno-ambiguous-member-template' support",
+			:cxx, '', '-Wno-ambiguous-member-template')
+		return false if !result
 
-	def self.compiler_supports_feliminate_unused_debug?
-		create_temp_file("passenger-compile-check.c") do |filename, f|
+		# For some reason, GCC does not complain about -Wno-ambiguous-member-template
+		# not being supported unless the source contains another error. So we
+		# check for this.
+		create_temp_file("passenger-compile-check.cpp") do |filename, f|
+			source = %Q{
+				void foo() {
+					return error;
+				}
+			}
+			f.puts(source)
 			f.close
 			begin
-				command = create_compiler_command(:c,
+				command = create_compiler_command(:cxx,
 					"-c '#{filename}' -o '#{filename}.o'",
-					'-feliminate-unused-debug-symbols -feliminate-unused-debug-types')
-				result = run_compiler("Checking for C compiler '--feliminate-unused-debug-{symbols,types}' support",
-					command, filename, '', true)
-				return result && result[:output].empty?
+					'-Wno-ambiguous-member-template')
+				result = run_compiler("Checking whether C++ compiler '-Wno-ambiguous-member-template' support is *really* supported",
+					command, filename, source, :always)
 			ensure
 				File.unlink("#{filename}.o") rescue nil
 			end
 		end
+
+		return result && result[:output] !~ /-Wno-ambiguous-member-template/
 	end
-	
+	memoize :compiler_supports_wno_ambiguous_member_template?, true
+
+	def self.cc_supports_feliminate_unused_debug?
+		return cc_or_cxx_supports_feliminate_unused_debug?(:c)
+	end
+	memoize :cc_supports_feliminate_unused_debug?, true
+
+	def self.cxx_supports_feliminate_unused_debug?
+		return cc_or_cxx_supports_feliminate_unused_debug?(:cxx)
+	end
+	memoize :cxx_supports_feliminate_unused_debug?, true
+
 	# Returns whether compiling C++ with -fvisibility=hidden might result
 	# in tons of useless warnings, like this:
 	# http://code.google.com/p/phusion-passenger/issues/detail?id=526
 	# This appears to be a bug in older g++ versions:
 	# http://gcc.gnu.org/ml/gcc-patches/2006-07/msg00861.html
 	# Warnings should be suppressed with -Wno-attributes.
-	def self.compiler_visibility_flag_generates_warnings?
-		if RUBY_PLATFORM =~ /linux/ && `#{cxx} -v 2>&1` =~ /gcc version (.*?)/
+	def self.cc_visibility_flag_generates_warnings?
+		if os_name =~ /linux/ && `#{cc} -v 2>&1` =~ /gcc version (.*?)/
+			return $1 <= "4.1.2"
+		else
+			return false
+		end
+	end
+	memoize :cc_visibility_flag_generates_warnings?, true
+
+	def self.cxx_visibility_flag_generates_warnings?
+		if os_name =~ /linux/ && `#{cxx} -v 2>&1` =~ /gcc version (.*?)/
 			return $1 <= "4.1.2"
 		else
 			return false
 		end
 	end
-	memoize :compiler_visibility_flag_generates_warnings?, true
+	memoize :cxx_visibility_flag_generates_warnings?, true
 	
+	def self.adress_sanitizer_flag
+		if cc_is_clang?
+			if `#{cc} --help` =~ /-fsanitize=/
+				return "-fsanitize=address"
+			else
+				return "-faddress-sanitizer"
+			end
+		else
+			return nil
+		end
+	end
+	memoize :adress_sanitizer_flag
+
+	def self.has_rt_library?
+		return try_link("Checking for -lrt support",
+			:c, "int main() { return 0; }\n", '-lrt')
+	end
+	memoize :has_rt_library?, true
+
 	def self.has_math_library?
 		return try_link("Checking for -lmath support",
 			:c, "int main() { return 0; }\n", '-lmath')
@@ -327,6 +444,15 @@ public
 			:c, '#include <alloca.h>')
 	end
 	memoize :has_alloca_h?, true
+
+	def self.has_accept4?
+		return try_compile("Checking for accept4()", :c, %Q{
+			#define _GNU_SOURCE
+			#include <sys/socket.h>
+			static void *foo = accept4;
+		})
+	end
+	memoize :has_accept4?, true
 	
 	# C compiler flags that should be passed in order to enable debugging information.
 	def self.debugging_cflags
@@ -335,10 +461,10 @@ public
 		# -ggdb instead.
 		#
 		# In any case we'll always want to use -ggdb for better GDB debugging.
-		if cc_is_clang? || cxx_is_clang?
-			return '-g'
-		else
+		if cc_is_gcc?
 			return '-ggdb'
+		else
+			return '-g'
 		end
 	end
 
@@ -346,7 +472,7 @@ public
 		if !ENV['DMALLOC_LIBS'].to_s.empty?
 			return ENV['DMALLOC_LIBS']
 		end
-		if RUBY_PLATFORM =~ /darwin/
+		if os_name == "macosx"
 			['/opt/local', '/usr/local', '/usr'].each do |prefix|
 				filename = "#{prefix}/lib/libdmallocthcxx.a"
 				if File.exist?(filename)
@@ -361,7 +487,7 @@ public
 	memoize :dmalloc_ldflags
 
 	def self.electric_fence_ldflags
-		if RUBY_PLATFORM =~ /darwin/
+		if os_name == "macosx"
 			['/opt/local', '/usr/local', '/usr'].each do |prefix|
 				filename = "#{prefix}/lib/libefence.a"
 				if File.exist?(filename)
@@ -376,7 +502,7 @@ public
 	memoize :electric_fence_ldflags
 	
 	def self.export_dynamic_flags
-		if RUBY_PLATFORM =~ /linux/
+		if os_name == "linux"
 			return '-rdynamic'
 		else
 			return nil
@@ -411,6 +537,15 @@ public
 		end
 	end
 	memoize :gnu_make, true
+	
+	def self.xcode_select_version
+		if find_command('xcode-select')
+			`xcode-select --version` =~ /version (.+)\./
+			return $1
+		else
+			return nil
+		end
+	end
 end
 
 end # module PhusionPassenger