a2dismod(options = {})
click to toggle source
The absolute path to the 'a2enmod' executable.
def self.a2dismod(options = {})
apxs2 = options[:apxs2] || self.apxs2
dir = File.dirname(apxs2)
if dir == "/usr/bin" || dir == "/usr/sbin"
if env_defined?('A2DISMOD')
return ENV['A2DISMOD']
else
return find_apache2_executable("a2dismod", options)
end
end
end
a2enmod(options = {})
click to toggle source
The absolute path to the 'a2enmod' executable.
def self.a2enmod(options = {})
apxs2 = options[:apxs2] || self.apxs2
dir = File.dirname(apxs2)
if dir == "/usr/bin" || dir == "/usr/sbin"
if env_defined?('A2ENMOD')
return ENV['A2ENMOD']
else
return find_apache2_executable("a2enmod", options)
end
else
return nil
end
end
adress_sanitizer_flag()
click to toggle source
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
apache2_bindir(options = {})
click to toggle source
The absolute path to the Apache 2 'bin' directory, or nil if unknown.
def self.apache2_bindir(options = {})
apxs2 = options[:apxs2] || self.apxs2
if apxs2.nil?
return nil
else
return `#{apxs2} -q BINDIR 2>/dev/null`.strip
end
end
apache2_module_c_or_cxxflags(language, with_apr_flags = true)
click to toggle source
The C compiler flags that are necessary to compile an Apache module. Also
includes APR and APU compiler flags if with_apr_flags is true.
def self.apache2_module_c_or_cxxflags(language, with_apr_flags = true)
flags = [""]
if (language == :c && cc_is_sun_studio?) || (language == :cxx && cxx_is_sun_studio?)
flags << "-KPIC"
else
flags << "-fPIC"
end
if with_apr_flags
if language == :c
flags << apr_cflags
flags << apu_cflags
else
flags << apr_cxxflags
flags << apu_cxxflags
end
end
if !apxs2.nil?
apxs2_flags = `#{apxs2} -q CFLAGS`.strip << " -I" << `#{apxs2} -q INCLUDEDIR`.strip
apxs2_flags.gsub!(/-O\d? /, '')
if os_name =~ /solaris/
if (language == :c && !cc_is_sun_studio?) || (language == :cxx && !cxx_is_sun_studio?)
options = apxs2_flags.split
options.reject! { |f| f =~ /^\-x/ }
options.reject! { |f| f =~ /^\-Xa/ }
options.reject! { |f| f =~ /^\-fast/ }
options.reject! { |f| f =~ /^\-mt/ }
options.reject! { |f| f =~ /^\-W2/ }
apxs2_flags = options.join(' ')
apxs2_flags.gsub!(/ ?-Qoption cg ?/, " ")
end
end
if os_name == "linux" &&
linux_distro_tags.include?(:redhat) &&
apxs2 == "/usr/sbin/apxs" &&
httpd_architecture_bits == 64
apxs2_flags.gsub!('-m32 -march=i386 -mtune=generic', '')
end
apxs2_flags.strip!
flags << apxs2_flags
end
if !httpd.nil? && os_name == "macosx"
output = `file "#{httpd}"`.strip
if output =~ /Mach-O fat file/ && output !~ /for architecture/
architectures = ["i386", "ppc", "x86_64", "ppc64"]
else
architectures = []
output.split("\n").grep(/for architecture/).each do |line|
line =~ /for architecture (.*?)\)/
architectures << $1
end
end
architectures.reject! do |arch|
!compiler_supports_architecture?(arch)
end
architectures.map! do |arch|
"-arch #{arch}"
end
flags << architectures.compact.join(' ')
end
return flags.compact.join(' ').strip
end
apache2_module_cflags(with_apr_flags = true)
click to toggle source
Compiler and linker flags ################
def self.apache2_module_cflags(with_apr_flags = true)
return apache2_module_c_or_cxxflags(:c, with_apr_flags)
end
apache2_module_cxx_ldflags()
click to toggle source
Linker flags that are necessary for linking an Apache module. Already
includes APR and APU linker flags.
def self.apache2_module_cxx_ldflags
flags = ""
if !apxs2.nil?
flags << `#{apxs2} -q LDFLAGS`.strip
end
flags << " #{apache2_module_cxxflags} #{apr_cxx_ldflags} #{apu_cxx_ldflags}"
if cxx_is_sun_studio?
flags.gsub!("-fPIC", "-KPIC")
flags << " -KPIC" if !flags.include?("-KPIC")
else
flags << " -fPIC" if !flags.include?("-fPIC")
end
flags.strip!
flags
end
apache2_module_cxxflags(with_apr_flags = true)
click to toggle source
def self.apache2_module_cxxflags(with_apr_flags = true)
return apache2_module_c_or_cxxflags(:cxx, with_apr_flags)
end
apache2_sbindir(options = {})
click to toggle source
The absolute path to the Apache 2 'sbin' directory, or nil if unknown.
def self.apache2_sbindir(options = {})
apxs2 = options[:apxs2] || self.apxs2
if apxs2.nil?
return nil
else
return `#{apxs2} -q SBINDIR`.strip
end
end
apache2ctl(options = {})
click to toggle source
The absolute path to the 'apachectl' or 'apache2ctl' binary, or nil if not
found.
def self.apache2ctl(options = {})
return find_apache2_executable('apache2ctl', 'apachectl2', 'apachectl', options)
end
apache2ctl_V(options = nil)
click to toggle source
Run `apache2ctl -V` and return its output, or nil on failure.
We used to run `httpd -V`, but on systems like Ubuntu it depends on various
environment variables or directories, wich apache2ctl loads or initializes.
Because on some systems (mostly Ubuntu) `apache2ctl -V` attempts to parse
and load the config file, this command can fail because of configuration
file errors.
def self.apache2ctl_V(options = nil)
if options
apache2ctl = options[:apache2ctl] || self.apache2ctl(options)
else
apache2ctl = self.apache2ctl
end
if os_name == "linux" &&
linux_distro_tags.include?(:gentoo) &&
apache2ctl == "/usr/sbin/apache2ctl"
if options
httpd = options[:httpd] || self.httpd(options)
else
httpd = self.httpd
end
version_command = httpd
else
version_command = apache2ctl
end
if version_command
create_temp_file("apache2ctl_V") do |filename, f|
e_filename = Shellwords.escape(filename)
output = `#{version_command} -V 2>#{e_filename}`
if $? && $?.exitstatus == 0
stderr_text = File.open(filename, "rb") do |f2|
f2.read
end
stderr_text.sub!(/.*Could not reliably determine the server's fully qualified domain name.*\r?\n?/, "")
STDERR.write(stderr_text)
STDERR.flush
output
else
nil
end
end
else
nil
end
end
apr_c_ldflags()
click to toggle source
The linker flags that are necessary for linking programs that use APR.
def self.apr_c_ldflags
determine_apr_c_info[1]
end
apr_cflags()
click to toggle source
The C compiler flags that are necessary for programs that use APR.
def self.apr_cflags
determine_apr_c_info[0]
end
apr_config()
click to toggle source
The absolute path to the 'apr-config' or 'apr-1-config' executable, or nil
if not found.
def self.apr_config
if env_defined?('APR_CONFIG')
return ENV['APR_CONFIG']
elsif apxs2.nil?
return nil
else
filename = `#{apxs2} -q APR_CONFIG 2>/dev/null`.strip
if filename.empty?
apr_bindir = `#{apxs2} -q APR_BINDIR 2>/dev/null`.strip
if apr_bindir.empty?
return nil
else
return select_executable(apr_bindir,
"apr-1-config", "apr-config")
end
elsif File.exist?(filename)
return filename
else
return nil
end
end
end
apr_config_needed_for_building_apache_modules?()
click to toggle source
Returns whether it is necessary to use information outputted by
'apr-config' and 'apu-config' in order to compile an Apache module. When
Apache is installed with --with-included-apr, the APR/APU headers are
placed into the same directory as the Apache headers, and so 'apr-config'
and 'apu-config' won't be necessary in that case.
def self.apr_config_needed_for_building_apache_modules?
return !try_compile("whether APR is needed for building Apache modules",
:c, "#include <apr.h>\n", apache2_module_cflags(false))
end
apr_cxx_ldflags()
click to toggle source
The linker flags that are necessary for linking C++ programs that use APR.
def self.apr_cxx_ldflags
determine_apr_cxx_info[1]
end
apr_cxxflags()
click to toggle source
The C++ compiler flags that are necessary for programs that use APR.
def self.apr_cxxflags
determine_apr_c_info[0]
end
apu_c_ldflags()
click to toggle source
The linker flags that are necessary for linking C programs that use
APR-Util.
def self.apu_c_ldflags
determine_apu_c_info[1]
end
apu_cflags()
click to toggle source
The C compiler flags that are necessary for programs that use APR-Util.
def self.apu_cflags
determine_apu_c_info[0]
end
apu_config()
click to toggle source
The absolute path to the 'apu-config' or 'apu-1-config' executable, or nil
if not found.
def self.apu_config
if env_defined?('APU_CONFIG')
return ENV['APU_CONFIG']
elsif apxs2.nil?
return nil
else
filename = `#{apxs2} -q APU_CONFIG 2>/dev/null`.strip
if filename.empty?
apu_bindir = `#{apxs2} -q APU_BINDIR 2>/dev/null`.strip
if apu_bindir.empty?
return nil
else
return select_executable(apu_bindir,
"apu-1-config", "apu-config")
end
elsif File.exist?(filename)
return filename
else
return nil
end
end
end
apu_cxx_ldflags()
click to toggle source
The linker flags that are necessary for linking C++ programs that use
APR-Util.
def self.apu_cxx_ldflags
determine_apu_cxx_info[1]
end
apu_cxxflags()
click to toggle source
The C++ compiler flags that are necessary for programs that use APR-Util.
def self.apu_cxxflags
determine_apu_cxx_info[0]
end
apxs2()
click to toggle source
The absolute path to the 'apxs' or 'apxs2' executable, or nil if not found.
def self.apxs2
if env_defined?("APXS2")
return ENV["APXS2"]
end
['apxs2', 'apxs'].each do |name|
command = find_command(name)
if !command.nil?
return command
end
end
return nil
end
cache_dir()
click to toggle source
def self.cache_dir
return @@cache_dir
end
cache_dir=(value)
click to toggle source
def self.cache_dir=(value)
@@cache_dir = value
end
cc()
click to toggle source
def self.cc
return string_env('CC', default_cc)
end
cc_is_clang?()
click to toggle source
def self.cc_is_clang?
`#{cc} --version 2>&1` =~ /clang version/
end
cc_is_gcc?()
click to toggle source
def self.cc_is_gcc?
`#{cc} -v 2>&1` =~ /gcc version/
end
cc_is_sun_studio?()
click to toggle source
def self.cc_is_sun_studio?
`#{cc} -V 2>&1` =~ /Sun C/ || `#{cc} -flags 2>&1` =~ /Sun C/
end
cc_supports_feliminate_unused_debug?()
click to toggle source
def self.cc_supports_feliminate_unused_debug?
return cc_or_cxx_supports_feliminate_unused_debug?(:c)
end
cc_supports_no_tls_direct_seg_refs_option?()
click to toggle source
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
cc_supports_visibility_flag?()
click to toggle source
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
cc_supports_wno_attributes_flag?()
click to toggle source
def self.cc_supports_wno_attributes_flag?
return try_compile_with_warning_flag(
"Checking for C compiler '-Wno-attributes' support",
:c, '', '-Wno-attributes')
end
cc_supports_wno_missing_field_initializers_flag?()
click to toggle source
def self.cc_supports_wno_missing_field_initializers_flag?
return try_compile_with_warning_flag(
"Checking for C compiler '-Wno-missing-field-initializers' support",
:c, '', '-Wno-missing-field-initializers')
end
cc_visibility_flag_generates_warnings?()
click to toggle source
clear_memoizations()
click to toggle source
Clears all memoized values. However, the disk cache (if any is configured)
is still used.
def self.clear_memoizations
class_variables.each do |name|
if name.to_s =~ /^@@has_memoized_/
class_variable_set(name, false)
end
end
end
compiler_supports_architecture?(arch)
click to toggle source
Checks whether the compiler supports "-arch #{arch}".
def self.compiler_supports_architecture?(arch)
return try_compile("Checking for C compiler '-arch' support",
:c, '', "-arch #{arch}")
end
compiler_supports_wno_ambiguous_member_template?()
click to toggle source
def self.compiler_supports_wno_ambiguous_member_template?
try_compile_with_warning_flag(
"Checking for C++ compiler '-Wno-ambiguous-member-template' support",
:cxx, '', '-Wno-ambiguous-member-template')
end
cpu_architectures()
click to toggle source
Returns a list of all CPU architecture names that the current machine CPU
supports. If there are multiple such architectures then the first item in
the result denotes that OS runtime's main/preferred architecture.
This function normalizes some names. For example x86 is always reported as
"x86" regardless of whether the OS reports it as "i386" or "i686". x86_64
is always reported as "x86_64" even if the OS reports it as "amd64".
Please note that even if the CPU supports multiple architectures, the
operating system might not. For example most x86 CPUs nowadays also support
x86_64, but x86_64 Linux systems require various x86 compatibility
libraries to be installed before x86 executables can be run. This function
does not detect whether these compatibility libraries are installed. The
only guarantee that you have is that the OS can run executables in the
architecture denoted by the first item in the result.
For example, on x86_64 Linux this function can return ["x86_64", "x86"].
This indicates that the CPU supports both of these architectures, and that
the OS's main/preferred architecture is x86_64. Most executables on the
system are thus be x86_64. It is guaranteed that the OS can run x86_64
executables, but not x86 executables per se.
Another example: on MacOS X this function can return either
- "x86_64", "x86"
-
or ["x86", "x86_64"]. The former result indicates
OS X 10.6 (Snow Leopard) and beyond because starting from that version
everything is 64-bit by default. The latter result indicates an OS X
version older than 10.6.
def self.cpu_architectures
uname = uname_command
raise "The 'uname' command cannot be found" if !uname
if os_name == "macosx"
arch = `#{uname} -p`.strip
if arch == "i386"
major, minor, *rest = `sw_vers -productVersion`.strip.split(".")
major = major.to_i
minor = minor.to_i
if major >= 10 || (major == 10 && minor >= 6)
["x86_64", "x86"]
else
["x86", "x86_64"]
end
else
arch
end
else
arch = `#{uname} -p`.strip
if arch == "unknown" || arch =~ / / || arch =~ /Hz$/
arch = `#{uname} -m`.strip
end
if arch =~ /^i.86$/
arch = "x86"
elsif arch == "amd64"
arch = "x86_64"
end
if arch == "x86"
["x86"]
elsif arch == "x86_64"
["x86_64", "x86"]
else
[arch]
end
end
end
curl_flags()
click to toggle source
def self.curl_flags
result = `(curl-config --cflags) 2>/dev/null`.strip
if result.empty?
return nil
else
version = `curl-config --vernum`.strip
if version >= '070c01'
result << " -DHAS_CURL_EASY_RESET"
end
return result
end
end
curl_libs()
click to toggle source
def self.curl_libs
result = `(curl-config --libs) 2>/dev/null`.strip
if result.empty?
return nil
else
return result
end
end
curl_supports_ssl?()
click to toggle source
def self.curl_supports_ssl?
features = `(curl-config --feature) 2>/dev/null`
return features =~ /SSL/
end
cxx()
click to toggle source
def self.cxx
return string_env('CXX', default_cxx)
end
cxx_11_flag()
click to toggle source
def self.cxx_11_flag
return nil if os_name =~ /freebsd/
source = %{
struct Foo {
Foo(Foo &&f) { }
};
}
if try_compile("Checking for C++ -std=gnu++11 compiler flag", :cxx, source, '-std=gnu++11')
return "-std=gnu++11"
elsif try_compile("Checking for C++ -std=c++11 compiler flag", :cxx, source, '-std=c++11')
return "-std=c++11"
else
return nil
end
end
cxx_binary_compatibility_id()
click to toggle source
Returns an identifier string that describes the current platform's binary
compatibility with regard to C/C++ binaries. Two systems with the same
binary compatibility identifiers should be able to run the same C/C++
binaries.
The the string depends on the following factors:
-
The operating system name.
-
Operating system runtime identifier. This may include the kernel version,
libc version, C++ ABI version, etc. Everything that is of interest for
binary compatibility with regard to C/C++ binaries.
-
Operating system default runtime architecture. This is not the same as the
CPU architecture; some CPUs support multiple architectures, e.g. Intel Core
2 Duo supports x86 and x86_64. Some operating systems actually support
multiple runtime architectures: a lot of x86_64 Linux distributions also
include 32-bit runtimes, and OS X Snow Leopard is x86_64 by default but all
system libraries also support x86. This component identifies the
architecture that is used when compiling a binary with the system's C++
compiler with its default options.
def self.cxx_binary_compatibility_id
if os_name == "macosx"
os_version_string = `sw_vers -productVersion`.strip
components = os_version_string.split(".")
os_version = "#{components[0]}.#{components[1]}"
os_runtime = os_version
os_arch = cpu_architectures[0]
if os_version >= "10.5" && os_arch =~ /^i.86$/
os_arch = "x86_64"
end
else
os_arch = cpu_architectures[0]
os_runtime = nil
end
return [os_arch, os_name, os_runtime].compact.join("-")
end
cxx_is_clang?()
click to toggle source
def self.cxx_is_clang?
`#{cxx} --version 2>&1` =~ /clang version/
end
cxx_is_gcc?()
click to toggle source
def self.cxx_is_gcc?
`#{cxx} -v 2>&1` =~ /gcc version/
end
cxx_is_sun_studio?()
click to toggle source
def self.cxx_is_sun_studio?
`#{cxx} -V 2>&1` =~ /Sun C/ || `#{cxx} -flags 2>&1` =~ /Sun C/
end
cxx_supports_feliminate_unused_debug?()
click to toggle source
def self.cxx_supports_feliminate_unused_debug?
return cc_or_cxx_supports_feliminate_unused_debug?(:cxx)
end
cxx_supports_no_tls_direct_seg_refs_option?()
click to toggle source
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
cxx_supports_visibility_flag?()
click to toggle source
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
cxx_supports_wno_attributes_flag?()
click to toggle source
def self.cxx_supports_wno_attributes_flag?
return try_compile_with_warning_flag(
"Checking for C++ compiler '-Wno-attributes' support",
:cxx, '', '-Wno-attributes')
end
cxx_supports_wno_missing_field_initializers_flag?()
click to toggle source
def self.cxx_supports_wno_missing_field_initializers_flag?
return try_compile_with_warning_flag(
"Checking for C++ compiler '-Wno-missing-field-initializers' support",
:cxx, '', '-Wno-missing-field-initializers')
end
cxx_supports_wno_unused_local_typedefs_flag?()
click to toggle source
def self.cxx_supports_wno_unused_local_typedefs_flag?
return try_compile_with_warning_flag(
"Checking for C++ compiler '-Wno-unused-local-typedefs' support",
:cxx, '', '-Wno-unused-local-typedefs')
end
cxx_visibility_flag_generates_warnings?()
click to toggle source
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
debugging_cflags()
click to toggle source
C compiler flags that should be passed in order to enable debugging
information.
def self.debugging_cflags
if cc_is_gcc?
return '-ggdb'
else
return '-g'
end
end
default_cc()
click to toggle source
def self.default_cc
if PlatformInfo.find_command('cc')
return 'cc'
else
return 'gcc'
end
end
default_cxx()
click to toggle source
def self.default_cxx
if PlatformInfo.find_command('c++')
return 'c++'
else
return 'g++'
end
end
dmalloc_ldflags()
click to toggle source
def self.dmalloc_ldflags
if !ENV['DMALLOC_LIBS'].to_s.empty?
return ENV['DMALLOC_LIBS']
end
if os_name == "macosx"
['/opt/local', '/usr/local', '/usr'].each do |prefix|
filename = "#{prefix}/lib/libdmallocthcxx.a"
if File.exist?(filename)
return filename
end
end
return nil
else
return "-ldmallocthcxx"
end
end
electric_fence_ldflags()
click to toggle source
def self.electric_fence_ldflags
if os_name == "macosx"
['/opt/local', '/usr/local', '/usr'].each do |prefix|
filename = "#{prefix}/lib/libefence.a"
if File.exist?(filename)
return filename
end
end
return nil
else
return "-lefence"
end
end
env_defined?(name)
click to toggle source
def self.env_defined?(name)
return !ENV[name].nil? && !ENV[name].empty?
end
export_dynamic_flags()
click to toggle source
def self.export_dynamic_flags
if os_name == "linux"
return '-rdynamic'
else
return nil
end
end
find_all_commands(name)
click to toggle source
def self.find_all_commands(name)
search_dirs = ENV['PATH'].to_s.split(File::PATH_SEPARATOR)
search_dirs.concat(%(/bin /sbin /usr/bin /usr/sbin /usr/local/bin /usr/local/sbin))
["/opt/*/bin", "/opt/*/sbin", "/usr/local/*/bin", "/usr/local/*/sbin"].each do |glob|
search_dirs.concat(Dir[glob])
end
Dir["/usr/apache2/*/bin"].each do |bindir|
search_dirs << bindir
Dir["#{bindir}/*"].each do |binsubdir|
if File.directory?(binsubdir)
search_dirs << binsubdir
end
end
end
search_dirs.delete("")
search_dirs.uniq!
result = []
search_dirs.each do |directory|
path = File.join(directory, name)
if !File.exist?(path)
log "Looking for #{path}: not found"
elsif !File.file?(path)
log "Looking for #{path}: found, but is not a file"
elsif !File.executable?(path)
log "Looking for #{path}: found, but is not executable"
else
log "Looking for #{path}: found"
result << path
end
end
return result
end
find_apache2_executable(*possible_names)
click to toggle source
Find an executable in the Apache 'bin' and 'sbin' directories. Returns nil
if not found.
def self.find_apache2_executable(*possible_names)
if possible_names.last.is_a?(Hash)
options = possible_names.pop
options = nil if options.empty?
end
if options
dirs = options[:dirs] || [apache2_bindir(options), apache2_sbindir(options)]
else
dirs = [apache2_bindir, apache2_sbindir]
end
dirs.each do |bindir|
if bindir.nil?
next
end
possible_names.each do |name|
filename = "#{bindir}/#{name}"
if !File.exist?(filename)
log "Looking for #{filename}: not found"
elsif !File.file?(filename)
log "Looking for #{filename}: found, but is not a file"
elsif !File.executable?(filename)
log "Looking for #{filename}: found, but is not executable"
else
log "Looking for #{filename}: found"
return filename
end
end
end
return nil
end
find_command(name, is_executable = true)
click to toggle source
Check whether the specified command is in $PATH, and return its absolute
filename. Returns nil if the command is not found.
This function exists because system('which') doesn't always behave
correctly, for some weird reason.
When `is_executable` is true, this function checks whether there is an
executable named `name` in $PATH. When false, it assumes that `name` is not
an executable name but a command string (e.g. "ccache gcc"). It then infers
the executable name ("ccache") from the command string, and checks for that
instead.
def self.find_command(name, is_executable = true)
name = name.to_s
if !is_executable && name =~ / /
name = name.sub(/ .*/, '')
end
if name =~ /^\//
if File.executable?(name)
return name
else
return nil
end
else
ENV['PATH'].to_s.split(File::PATH_SEPARATOR).each do |directory|
next if directory.empty?
path = File.join(directory, name)
if File.file?(path) && File.executable?(path)
return path
end
end
return nil
end
end
gem_command(options = {})
click to toggle source
Returns the correct 'gem' command for this Ruby interpreter. If `:sudo
=> true` is given, then the gem command is prefixed by a sudo command if
filesystem permissions require this.
def self.gem_command(options = {})
command = ruby_tool_command('gem')
if options[:sudo] && gem_install_requires_sudo?
command = "#{ruby_sudo_command} #{command}"
end
return command
end
gem_install_requires_sudo?()
click to toggle source
Returns whether running 'gem install' as the current user requires sudo.
def self.gem_install_requires_sudo?
`#{gem_command} env` =~ /INSTALLATION DIRECTORY: (.+)/
if install_dir = $1
return !File.writable?(install_dir)
else
return nil
end
end
gnu_make()
click to toggle source
def self.gnu_make
if result = string_env('GMAKE')
return result
else
result = find_command('gmake')
if !result
result = find_command('make')
if result
if `#{result} --version 2>&1` =~ /GNU/
return result
else
return nil
end
else
return nil
end
else
return result
end
end
end
has_accept4?()
click to toggle source
def self.has_accept4?
return try_compile("Checking for accept4()", :c, %{
#define _GNU_SOURCE
#include <sys/socket.h>
static void *foo = accept4;
})
end
has_alloca_h?()
click to toggle source
def self.has_alloca_h?
return try_compile("Checking for alloca.h",
:c, '#include <alloca.h>')
end
has_math_library?()
click to toggle source
def self.has_math_library?
return try_link("Checking for -lmath support",
:c, "int main() { return 0; }\n", '-lmath')
end
has_rt_library?()
click to toggle source
def self.has_rt_library?
return try_link("Checking for -lrt support",
:c, "int main() { return 0; }\n", '-lrt')
end
httpd(options = {})
click to toggle source
The absolute path to the Apache binary (that is, 'httpd', 'httpd2',
'apache' or 'apache2'), or nil if not found.
def self.httpd(options = {})
apxs2 = options[:apxs2] || self.apxs2
if env_defined?('HTTPD')
return ENV['HTTPD']
elsif apxs2.nil?
["apache2", "httpd2", "apache", "httpd"].each do |name|
command = find_command(name)
if !command.nil?
return command
end
end
return nil
else
return find_apache2_executable(`#{apxs2} -q TARGET`.strip, options)
end
end
httpd_actual_error_log(options = nil)
click to toggle source
def self.httpd_actual_error_log(options = nil)
if config_file = httpd_default_config_file(options)
begin
contents = File.open(config_file, "rb") { |f| f.read }
rescue Errno::ENOENT
log "#{config_file} does not exist"
return nil
rescue Errno::EACCES
log "Unable to open #{config_file} for reading"
return nil
end
contents.gsub!(/^[ \t]*#.*/, '')
if contents =~ /^[ \t]*ErrorLog[ \t]+(.+)[ \t]*$/
filename = unescape_apache_config_value($1, options)
if filename && filename !~ /\A\//
if root = httpd_default_root(options)
return "#{root}/#{filename}"
else
return nil
end
else
return filename
end
elsif contents =~ /ErrorLog/
log "Unable to parse ErrorLog directive in Apache configuration file"
return nil
else
log "No ErrorLog directive in Apache configuration file"
return httpd_default_error_log(options)
end
else
return nil
end
end
httpd_architecture_bits(options = nil)
click to toggle source
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
info = apache2ctl_V(options)
else
info = apache2ctl_V
end
if info
info =~ %{Architecture:(.*)}
text = $1
if text =~ /32/
32
elsif text =~ /64/
64
else
nil
end
else
nil
end
end
httpd_default_config_file(options = nil)
click to toggle source
The default Apache configuration file, or nil if Apache is not found.
def self.httpd_default_config_file(options = nil)
if options
info = apache2ctl_V(options)
else
info = apache2ctl_V
end
if info
info =~ /-D SERVER_CONFIG_FILE="(.+)"$/
filename = $1
if filename =~ /\A\//
return filename
else
if root = httpd_default_root(options)
return "#{root}/#{filename}"
else
return nil
end
end
else
return nil
end
end
httpd_default_error_log(options = nil)
click to toggle source
The default Apache error log's filename, as it is compiled into the Apache
main executable. This may not be the actual error log that is used. The
actual error log depends on the configuration file.
Returns nil if Apache is not detected, or if the default error log filename
cannot be detected.
def self.httpd_default_error_log(options = nil)
if info = apache2ctl_V(options)
info =~ /-D DEFAULT_ERRORLOG="(.+)"$/
filename = $1
if filename =~ /\A\//
return filename
else
if root = httpd_default_root(options)
return "#{root}/#{filename}"
else
return nil
end
end
else
return nil
end
end
httpd_default_root(options = nil)
click to toggle source
The default Apache root directory, as specified by its compilation
parameters. This may be different from the value of the ServerRoot
directive.
def self.httpd_default_root(options = nil)
if options
info = apache2ctl_V(options)
else
info = apache2ctl_V
end
if info
info =~ / -D HTTPD_ROOT="(.+)"$/
return $1
else
return nil
end
end
httpd_envvars_file(options = nil)
click to toggle source
The location of the Apache envvars file, which exists on some systems such
as Ubuntu. Returns nil if Apache is not found or if the envvars file is not
found.
def self.httpd_envvars_file(options = nil)
if options
httpd = options[:httpd] || self.httpd(options)
else
httpd = self.httpd
end
httpd_dir = File.dirname(httpd)
if httpd_dir == "/usr/bin" || httpd_dir == "/usr/sbin"
if File.exist?("/etc/apache2/envvars")
return "/etc/apache2/envvars"
elsif File.exist?("/etc/httpd/envvars")
return "/etc/httpd/envvars"
end
end
conf_dir = File.expand_path(File.dirname(httpd) + "/../conf")
if File.exist?("#{conf_dir}/envvars")
return "#{conf_dir}/envvars"
end
return nil
end
httpd_included_config_files(config_file, options = nil)
click to toggle source
Given an Apache config file, returns the a hash with the following
elements:
* `:files` - An array containing `config_file`, as well as all config files
included from that config file, including recursively included
ones. Only filenames that actually exist are put here.
* `:unreadable_files` - All config files that this function was unable
to read.
def self.httpd_included_config_files(config_file, options = nil)
state = {
:files => { config_file => true },
:unreadable_files => [],
:root => httpd_default_root(options)
}
scan_for_included_apache2_config_files(config_file, state, options)
return {
:files => state[:files].keys,
:unreadable_files => state[:unreadable_files]
}
end
httpd_infer_envvar(varname, options = nil)
click to toggle source
def self.httpd_infer_envvar(varname, options = nil)
if envfile = httpd_envvars_file(options)
result = `. '#{envfile}' && echo $#{varname}`.strip
if $? && $?.exitstatus == 0
return result
else
return nil
end
else
return nil
end
end
httpd_mods_available_directory(options = nil)
click to toggle source
Returns the path to the Apache `mods-available` subdirectory, or nil if
it's not supported by this Apache.
def self.httpd_mods_available_directory(options = nil)
config_file = httpd_default_config_file(options)
return nil if !config_file
config_dir = File.dirname(config_file)
if config_dir == "/etc/httpd" || config_dir == "/etc/apache2"
if File.exist?("#{config_dir}/mods-available") &&
File.exist?("#{config_dir}/mods-enabled")
return "#{config_dir}/mods-available"
else
return nil
end
else
return nil
end
end
httpd_mods_enabled_directory(options = nil)
click to toggle source
Returns the path to the Apache `mods-enabled` subdirectory, or nil if it's
not supported by this Apache.
def self.httpd_mods_enabled_directory(options = nil)
config_file = httpd_default_config_file(options)
return nil if !config_file
config_dir = File.dirname(config_file)
if config_dir == "/etc/httpd" || config_dir == "/etc/apache2"
if File.exist?("#{config_dir}/mods-available") &&
File.exist?("#{config_dir}/mods-enabled")
return "#{config_dir}/mods-enabled"
else
return nil
end
else
return nil
end
end
httpd_version(options = nil)
click to toggle source
The Apache version, or nil if Apache is not found.
def self.httpd_version(options = nil)
if options
httpd = options[:httpd] || self.httpd(options)
else
httpd = self.httpd
end
if httpd
`#{httpd} -v` =~ %{Apache/([\d\.]+)}
return $1
else
return nil
end
end
in_rvm?()
click to toggle source
Returns whether the current Ruby interpreter is managed by RVM.
def self.in_rvm?
bindir = rb_config['bindir']
return bindir.include?('/.rvm/') || bindir.include?('/rvm/')
end
library_extension()
click to toggle source
The current platform's shared library extension ('so' on most Unices).
def self.library_extension
if os_name == "macosx"
return "bundle"
else
return "so"
end
end
linux_distro()
click to toggle source
An identifier for the current Linux distribution. nil if the operating
system is not Linux.
def self.linux_distro
tags = linux_distro_tags
if tags
return tags.first
else
return nil
end
end
log_implementation()
click to toggle source
def self.log_implementation
return @@log_implementation
end
log_implementation=(impl)
click to toggle source
def self.log_implementation=(impl)
@@log_implementation = impl
end
make()
click to toggle source
def self.make
return string_env('MAKE', find_command('make'))
end
os_name()
click to toggle source
Returns the operating system's name. This name is in lowercase and contains
no spaces, and thus is suitable to be used in some kind of ID. It may
contain a version number. Linux is always identified as "linux". OS X is
always identified as "macosx". Identifiers for other operating systems may
contain a version number, e.g. "freebsd10".
def self.os_name
if rb_config['target_os'] =~ /darwin/ && (sw_vers = find_command('sw_vers'))
return "macosx"
elsif rb_config['target_os'] =~ /^linux-/
return "linux"
else
return rb_config['target_os']
end
end
portability_c_ldflags()
click to toggle source
Extra flags that should always be passed to the C compiler when linking, to
be included last in the command string.
def self.portability_c_ldflags
return portability_c_or_cxx_ldflags(:c)
end
portability_cxx_ldflags()
click to toggle source
Extra flags that should always be passed to the C++ compiler when linking,
to be included last in the command string.
def self.portability_cxx_ldflags
return portability_c_or_cxx_ldflags(:cxx)
end
rake()
click to toggle source
Returns the absolute path to the Rake executable that belongs to the
current Ruby interpreter. Returns nil if it doesn't exist.
The return value may not be the actual correct invocation for Rake. Use `rake_command` for that.
def self.rake
return locate_ruby_tool('rake')
end
rake_command()
click to toggle source
Returns the correct command string for invoking the Rake executable that
belongs to the current Ruby interpreter. Returns nil if Rake is not found.
def self.rake_command
ruby_tool_command('rake')
end
rb_config()
click to toggle source
def self.rb_config
if defined?(::RbConfig)
return ::RbConfig::CONFIG
else
return ::Config::CONFIG
end
end
read_file(filename)
click to toggle source
def self.read_file(filename)
return File.open(filename, "rb") do |f|
f.read
end
rescue
return ""
end
requires_no_tls_direct_seg_refs?()
click to toggle source
def self.requires_no_tls_direct_seg_refs?
return File.exists?("/proc/xen/capabilities") && cpu_architectures[0] == "x86"
end
rspec()
click to toggle source
Returns the absolute path to the RSpec runner program that belongs to the
current Ruby interpreter. Returns nil if it doesn't exist.
def self.rspec
return locate_ruby_tool('rspec')
end
ruby_command()
click to toggle source
Returns correct command for invoking the current Ruby interpreter. In case
of RVM this function will return the path to the RVM wrapper script that
executes the current Ruby interpreter in the currently active gem set.
def self.ruby_command
if GEM_HOME && File.exist?("#{GEM_HOME}/wrappers/ruby")
return "#{GEM_HOME}/wrappers/ruby"
end
if in_rvm?
name = rvm_ruby_string
dirs = rvm_paths
if name && dirs
dirs.each do |dir|
filename = "#{dir}/wrappers/#{name}/ruby"
if File.exist?(filename)
contents = File.open(filename, 'rb') do |f|
f.read
end
if contents.include?("$HOME")
filename = nil
end
else
filename = nil
end
if filename
return filename
end
end
case rvm_installation_mode
when :single
repair_command = "rvm get stable && rvm reload && rvm repair all"
wrapper_command = "rvm wrapper #{rvm_ruby_string} --no-prefix --all"
when :multi
repair_command = "rvmsudo rvm get stable && rvm reload && rvmsudo rvm repair all"
wrapper_command = "rvmsudo rvm wrapper #{rvm_ruby_string} --no-prefix --all"
when :mixed
repair_command = "rvmsudo rvm get stable && rvm reload && rvm repair all"
wrapper_command = "rvm wrapper #{rvm_ruby_string} --no-prefix --all"
end
STDERR.puts "Your RVM wrapper scripts are too old, or some " +
"wrapper scripts are missing. Please update/regenerate " +
"them first by running:\n\n" +
" #{repair_command}\n\n" +
"If that doesn't seem to work, please run:\n\n" +
" #{wrapper_command}"
exit 1
else
STDERR.puts "Your RVM installation appears to be broken: the RVM " +
"path cannot be found. Please fix your RVM installation " +
"or contact the RVM developers for support."
exit 1
end
else
return ruby_executable
end
end
ruby_executable()
click to toggle source
Returns the full path to the current Ruby interpreter's executable file.
This might not be the actual correct command to use for invoking the Ruby
interpreter; use ruby_command instead.
def self.ruby_executable
@@ruby_executable ||=
rb_config['bindir'] + '/' + rb_config['RUBY_INSTALL_NAME'] + rb_config['EXEEXT']
end
ruby_extension_binary_compatibility_id()
click to toggle source
Returns a string that describes the current Ruby interpreter's extension
binary compatibility. A Ruby extension compiled for a certain Ruby
interpreter can also be loaded on a different Ruby interpreter with the
same binary compatibility identifier.
The result depends on the following factors:
-
Ruby engine name.
-
Ruby extension version. This is not the same as the Ruby language version,
which identifies language-level compatibility. This is rather about binary
compatibility of extensions. MRI seems to break source compatibility
between tiny releases, though patchlevel releases tend to be source and
binary compatible.
-
Ruby extension architecture. This is not necessarily the same as the
operating system runtime architecture or the CPU architecture. For example,
in case of JRuby, the extension architecture is just "java" because all
extensions target the Java platform; the architecture the JVM was compiled
for has no effect on compatibility. On systems with universal binaries
support there may be multiple architectures. In this case the architecture
is "universal" because extensions must be able to support all of the Ruby
executable's architectures.
-
The operating system for which the Ruby interpreter was compiled.
def self.ruby_extension_binary_compatibility_id
ruby_engine = defined?(RUBY_ENGINE) ? RUBY_ENGINE : "ruby"
ruby_ext_version = RUBY_VERSION
if RUBY_PLATFORM =~ /darwin/
if RUBY_PLATFORM =~ /universal/
ruby_arch = "universal"
else
output = `file -L "#{ruby_executable}"`.strip
ruby_arch = output.sub(/.* /, '')
if ruby_arch == "executable"
if output =~ /Mach-O 64-bit/
ruby_arch = "x86_64"
else
raise "Cannot autodetect the Ruby interpreter's architecture"
end
end
end
elsif RUBY_PLATFORM == "java"
ruby_arch = "java"
else
ruby_arch = cpu_architectures[0]
end
return "#{ruby_engine}-#{ruby_ext_version}-#{ruby_arch}-#{os_name}"
end
ruby_sudo_command()
click to toggle source
Returns either 'sudo' or 'rvmsudo' depending on whether the current Ruby
interpreter is managed by RVM.
def self.ruby_sudo_command
if in_rvm?
return "rvmsudo"
else
return "sudo"
end
end
ruby_sudo_shell_command(args = nil)
click to toggle source
Returns a `sudo` or `rvmsudo` command that spawns a shell, depending on
whether the current Ruby interpreter is managed by RVM.
def self.ruby_sudo_shell_command(args = nil)
if in_rvm?
shell = ENV['SHELL'].to_s
if shell.empty?
begin
user = Etc.getpwuid(0)
rescue ArgumentError
user = nil
end
shell = user.shell if user
shell = "bash" if !shell || shell.empty?
end
result = "rvmsudo "
result << "#{args} " if args
result << shell
return result
else
return "sudo -s #{args}".strip
end
end
ruby_supports_fork?()
click to toggle source
Returns whether the Ruby interpreter supports process forking.
def self.ruby_supports_fork?
return Process.respond_to?(:fork) &&
RUBY_ENGINE != "jruby" &&
RUBY_ENGINE != "macruby" &&
rb_config['target_os'] !~ /mswin|windows|mingw/
end
rvm_installation_mode()
click to toggle source
Returns the RVM installation mode: :single - RVM is installed in
single-user mode. :multi - RVM is installed in multi-user mode. :mixed -
RVM is in a mixed-mode installation. nil - The current Ruby interpreter
is not using RVM.
def self.rvm_installation_mode
if in_rvm?
if ENV['rvm_path'] =~ /\.rvm/
return :single
else
if GEM_HOME =~ /\.rvm/
return :mixed
else
return :multi
end
end
else
return nil
end
end
rvm_paths()
click to toggle source
If the current Ruby interpreter is managed by RVM, returns all directories
in which RVM places its working files. This is usually ~/.rvm or
/usr/local/rvm, but in mixed-mode installations there can be multiple such
paths.
Otherwise returns nil.
def self.rvm_paths
if in_rvm?
result = []
[ENV['rvm_path'], "#{PhusionPassenger.home_dir}/.rvm", "/usr/local/rvm"].each do |path|
next if path.nil?
rubies_path = File.join(path, 'rubies')
wrappers_path = File.join(path, 'wrappers')
gems_path = File.join(path, 'gems')
if File.directory?(path) && (File.directory?(rubies_path) ||
File.directory?(wrappers_path) || File.directory?(gems_path))
result << path
end
end
if result.empty?
STDERR.puts "Unable to locate the RVM path. Your RVM installation " +
"is probably too old. Please update it with " +
"'rvm get head && rvm reload && rvm repair all'."
exit 1
else
return result
end
else
return nil
end
end
rvm_ruby_string()
click to toggle source
If the current Ruby interpreter is managed by RVM, returns the RVM name
which identifies the current Ruby interpreter plus the currently active
gemset, e.g. something like this: "ruby-1.9.2-p0@mygemset"
Returns nil otherwise.
def self.rvm_ruby_string
if in_rvm?
if GEM_HOME && GEM_HOME =~ %{rvm/gems/(.+)}
return $1.sub(/\/.*/, '')
end
if GEM_PATH
GEM_PATH.split(':').each do |gem_path|
if gem_path =~ %{rvm/gems/(.+)}
return $1.sub(/\/.*/, '')
end
end
end
matching_path = $LOAD_PATH.find_all do |item|
item.include?("rvm/gems/")
end
if matching_path && !matching_path.empty?
subpath = matching_path.to_s.gsub(/^.*rvm\/gems\//, '')
result = subpath.split('/').first
return result if result
end
STDERR.puts "Unable to autodetect the currently active RVM gem " +
"set name. This could happen if you ran this program using 'sudo' " +
"instead of 'rvmsudo'. When using RVM, you're always supposed to " +
"use 'rvmsudo' instead of 'sudo!'.\n\n" +
"Please try rerunning this program using 'rvmsudo'. If that " +
"doesn't help, please contact this program's author for support."
exit 1
end
return nil
end
string_env(name, default_value = nil)
click to toggle source
def self.string_env(name, default_value = nil)
value = ENV[name]
if value.nil? || value.empty?
return default_value
else
return value
end
end
supports_lfence_instruction?()
click to toggle source
Returns whether the OS's main CPU architecture supports the x86/x86_64
lfence instruction.
def self.supports_lfence_instruction?
arch = cpu_architectures[0]
return arch == "x86_64" || (arch == "x86" &&
try_compile_and_run("Checking for lfence instruction support", :c, %{
int
main() {
__asm__ __volatile__ ("lfence" ::: "memory");
return 0;
}
}))
end
supports_sfence_instruction?()
click to toggle source
Returns whether the OS's main CPU architecture supports the x86/x86_64
sfence instruction.
def self.supports_sfence_instruction?
arch = cpu_architectures[0]
return arch == "x86_64" || (arch == "x86" &&
try_compile_and_run("Checking for sfence instruction support", :c, %{
int
main() {
__asm__ __volatile__ ("sfence" ::: "memory");
return 0;
}
}))
end
tmpdir()
click to toggle source
def self.tmpdir
result = ENV['TMPDIR']
if result && !result.empty?
return result.sub(/\/+\Z/, '')
else
return '/tmp'
end
end
tmpexedir()
click to toggle source
Returns the directory in which test executables should be placed. The
returned directory is guaranteed to be writable and guaranteed to not be
mounted with the 'noexec' option. If no such directory can be found then it
will raise a PlatformInfo::RuntimeError with
an appropriate error message.
def self.tmpexedir
basename = "test-exe.#{Process.pid}.#{Thread.current.object_id}"
attempts = []
dir = tmpdir
filename = "#{dir}/#{basename}"
begin
File.open(filename, 'w') do |f|
f.puts("#!/bin/sh")
end
File.chmod(0700, filename)
if system(filename)
return dir
else
attempts << { :dir => dir,
:error => "This directory's filesystem is mounted with the 'noexec' option." }
end
rescue Errno::ENOENT
attempts << { :dir => dir, :error => "This directory doesn't exist." }
rescue Errno::EACCES
attempts << { :dir => dir, :error => "This program doesn't have permission to write to this directory." }
rescue SystemCallError => e
attempts << { :dir => dir, :error => e.message }
ensure
File.unlink(filename) rescue nil
end
dir = Dir.pwd
filename = "#{dir}/#{basename}"
begin
File.open(filename, 'w') do |f|
f.puts("#!/bin/sh")
end
File.chmod(0700, filename)
if system(filename)
return dir
else
attempts << { :dir => dir,
:error => "This directory's filesystem is mounted with the 'noexec' option." }
end
rescue Errno::ENOENT
attempts << { :dir => dir, :error => "This directory doesn't exist." }
rescue Errno::EACCES
attempts << { :dir => dir, :error => "This program doesn't have permission to write to this directory." }
rescue SystemCallError => e
attempts << { :dir => dir, :error => e.message }
ensure
File.unlink(filename) rescue nil
end
message = "ERROR: Cannot find suitable temporary directory\n" +
"In order to run certain tests, this program " +
"must be able to write temporary\n" +
"executable files to some directory. However no such " +
"directory can be found. \n" +
"The following directories have been tried:\n\n"
attempts.each do |attempt|
message << " * #{attempt[:dir]}\n"
message << " #{attempt[:error]}\n"
end
message << "\nYou can solve this problem by telling this program what directory to write\n" <<
"temporary executable files to, as follows:\n" <<
"\n" <<
" Set the $TMPDIR environment variable to the desired directory's filename and\n" <<
" re-run this program.\n" <<
"\n" <<
"Notes:\n" <<
"\n" <<
" * If you're using 'sudo'/'rvmsudo', remember that 'sudo'/'rvmsudo' unsets all\n" <<
" environment variables, so you must set the environment variable *after*\n" <<
" having gained root privileges.\n" <<
" * The directory you choose must writeable and must not be mounted with the\n" <<
" 'noexec' option."
raise RuntimeError, message
end
try_compile(description, language, source, flags = nil)
click to toggle source
def self.try_compile(description, language, source, flags = nil)
extension = detect_language_extension(language)
create_temp_file("passenger-compile-check.#{extension}") do |filename, f|
f.puts(source)
f.close
command = create_compiler_command(language,
"-c '#{filename}' -o '#{filename}.o'",
flags)
return run_compiler(description, command, filename, source)
end
end
try_compile_and_run(description, language, source, flags = nil)
click to toggle source
def self.try_compile_and_run(description, language, source, flags = nil)
extension = detect_language_extension(language)
create_temp_file("passenger-run-check.#{extension}", tmpexedir) do |filename, f|
f.puts(source)
f.close
command = create_compiler_command(language,
"'#{filename}' -o '#{filename}.out'",
flags, true)
if run_compiler(description, command, filename, source)
log("Running #{filename}.out")
begin
output = `'#{filename}.out' 2>&1`
rescue SystemCallError => e
log("Command failed: #{e}")
return false
end
status = $?.exitstatus
log("Command exited with status #{status}. Output:\n--------------\n#{output}\n--------------")
return status == 0
else
return false
end
end
end
try_compile_with_warning_flag(description, language, source, flags = nil)
click to toggle source
Like try_compile, but
designed for checking whether a warning flag is supported. Compilers
sometimes do not error out upon encountering an unsupported warning flag,
but merely print a warning. This method checks for that too.
def self.try_compile_with_warning_flag(description, language, source, flags = nil)
extension = detect_language_extension(language)
result = nil
create_temp_file("passenger-compile-check.#{extension}") do |filename, f|
f.puts(source)
f.close
command = create_compiler_command(language,
"-c '#{filename}' -o '#{filename}.o'",
flags)
result = run_compiler(description, command, filename, source, true)
result = result && result[:result] && result[:output] !~ /unknown warning option/
end
return false if !result
create_temp_file("passenger-compile-check.#{extension}") do |filename, f|
source = %{
void foo() {
return error;
}
}
f.puts(source)
f.close
command = create_compiler_command(language,
"-c '#{filename}' -o '#{filename}.o'",
flags)
result = run_compiler("#{description} (really)", command, filename, source, :always)
end
result && !result[:output].include?(flags)
end
try_link(description, language, source, flags = nil)
click to toggle source
def self.try_link(description, language, source, flags = nil)
extension = detect_language_extension(language)
create_temp_file("passenger-link-check.#{extension}") do |filename, f|
f.puts(source)
f.close
command = create_compiler_command(language,
"'#{filename}' -o '#{filename}.out'",
flags, true)
return run_compiler(description, command, filename, source)
end
end
uname_command()
click to toggle source
Returns the `uname` command, or nil if `uname` cannot be found. In addition
to looking for `uname` in `PATH`, this method also looks for `uname` in
/bin and /usr/bin, just in case the user didn't configure its PATH
properly.
def self.uname_command
if result = find_command("uname")
result
elsif File.exist?("/bin/uname")
return "/bin/uname"
elsif File.exist?("/usr/bin/uname")
return "/usr/bin/uname"
else
return nil
end
end
verbose=(val)
click to toggle source
def self.verbose=(val)
@@verbose = val
end
verbose?()
click to toggle source
def self.verbose?
return @@verbose
end
xcode_select_version()
click to toggle source
def self.xcode_select_version
if find_command('xcode-select')
`xcode-select --version` =~ /version (.+)\./
return $1
else
return nil
end
end
zlib_flags()
click to toggle source
def self.zlib_flags
return nil
end
zlib_libs()
click to toggle source
def self.zlib_libs
return '-lz'
end
![[+]](../images/find.png "show/hide quicksearch")