passenger 5.0.0.beta3 → 5.0.0.rc1

data/lib/phusion_passenger/packaging.rb

@@ -23,146 +23,146 @@
 
 module PhusionPassenger
 
-module Packaging
-	# A list of HTML files that are generated with Asciidoc.
-	ASCII_DOCS = [
-		'doc/Users guide.html',
-		'doc/Users guide Apache.html',
-		'doc/Users guide Nginx.html',
-		'doc/Users guide Standalone.html',
-		'doc/Security of user switching support.html',
-		'doc/Design and Architecture.html'
-	]
+  module Packaging
+    # A list of HTML files that are generated with Asciidoc.
+    ASCII_DOCS = [
+      'doc/Users guide.html',
+      'doc/Users guide Apache.html',
+      'doc/Users guide Nginx.html',
+      'doc/Users guide Standalone.html',
+      'doc/Security of user switching support.html',
+      'doc/Design and Architecture.html'
+    ]
 
-	# Files that must be generated before packaging.
-	PREGENERATED_FILES = [
-		'ext/common/Constants.h',
-		'doc/Packaging.html',
-		'doc/CloudLicensingConfiguration.html',
-		'doc/ServerOptimizationGuide.html'
-	] + ASCII_DOCS
+    # Files that must be generated before packaging.
+    PREGENERATED_FILES = [
+      'ext/common/Constants.h',
+      'doc/Packaging.html',
+      'doc/CloudLicensingConfiguration.html',
+      'doc/ServerOptimizationGuide.html'
+    ] + ASCII_DOCS
 
-	USER_EXECUTABLES = [
-		'passenger',
-		'passenger-install-apache2-module',
-		'passenger-install-nginx-module',
-		'passenger-config'
-	]
+    USER_EXECUTABLES = [
+      'passenger',
+      'passenger-install-apache2-module',
+      'passenger-install-nginx-module',
+      'passenger-config'
+    ]
 
-	SUPER_USER_EXECUTABLES = [
-		'passenger-status',
-		'passenger-memory-stats'
-	]
+    SUPER_USER_EXECUTABLES = [
+      'passenger-status',
+      'passenger-memory-stats'
+    ]
 
-	# Used during native packaging. Specifies executables for
-	# which the shebang should NOT be set to #!/usr/bin/ruby,
-	# so that these executables can be run with any Ruby interpreter
-	# the user desires.
-	EXECUTABLES_WITH_FREE_RUBY = [
-		'passenger',
-		'passenger-config',
-		'passenger-install-apache2-module',
-		'passenger-install-nginx-module'
-	]
+    # Used during native packaging. Specifies executables for
+    # which the shebang should NOT be set to #!/usr/bin/ruby,
+    # so that these executables can be run with any Ruby interpreter
+    # the user desires.
+    EXECUTABLES_WITH_FREE_RUBY = [
+      'passenger',
+      'passenger-config',
+      'passenger-install-apache2-module',
+      'passenger-install-nginx-module'
+    ]
 
-	# A list of globs which match all files that should be packaged
-	# in the Phusion Passenger gem or tarball.
-	GLOB = [
-		'.gitignore',
-		'.travis.yml',
-		'.editorconfig',
-		'configure',
-		'Rakefile',
-		'Gemfile',
-		'Gemfile.lock',
-		'Vagrantfile',
-		'README.md',
-		'CONTRIBUTORS',
-		'CONTRIBUTING.md',
-		'LICENSE',
-		'CHANGELOG',
-		'INSTALL.md',
-		'NEWS',
-		'package.json',
-		'npm-shrinkwrap.json',
-		'passenger.gemspec',
-		'build/*.rb',
-		'lib/*.rb',
-		'lib/**/*.rb',
-		'lib/**/*.py',
-		'node_lib/**/*.js',
-		'bin/*',
-		'doc/**/*',
-		'man/*',
-		'debian.template/**/*',
-		'packaging/**/*',
-		'helper-scripts/**/*',
-		'ext/common/**/*.{cpp,c,h,hpp,md,erb}',
-		'ext/apache2/*.{cpp,h,hpp,c,erb}',
-		'ext/nginx/*.{c,cpp,h,erb}',
-		'ext/nginx/config',
-		'ext/boost/**/*',
-		'ext/libev/{LICENSE,Changes,README,Makefile.am,Makefile.in}',
-		'ext/libev/{*.m4,autogen.sh,config.guess,config.h.in,config.sub}',
-		'ext/libev/{configure,configure.ac,depcomp,install-sh,ltmain.sh,missing,mkinstalldirs}',
-		'ext/libev/{*.h,*.c}',
-		'ext/libeio/{LICENSE,Changes,README,Makefile.am,Makefile.in}',
-		'ext/libeio/{*.m4,autogen.sh,config.guess,config.h.in,config.sub}',
-		'ext/libeio/{configure,configure.ac,install-sh,ltmain.sh,missing,mkinstalldirs}',
-		'ext/libeio/{*.h,*.c}',
-		'ext/oxt/*.hpp',
-		'ext/oxt/*.cpp',
-		'ext/oxt/*.txt',
-		'ext/oxt/detail/*.hpp',
-		'ext/ruby/*.{c,rb}',
-		'dev/**/*',
-		'resources/**/*',
-		'test/.rspec',
-		'test/*.example',
-		'test/*.travis',
-		'test/*.rpm-automation',
-		'test/*.vagrant',
-		'test/*.supp',
-		'test/support/*.{c,cpp,h,rb}',
-		'test/tut/*',
-		'test/cxx/**/*.{cpp,h}',
-		'test/oxt/*.{cpp,hpp}',
-		'test/ruby/**/*',
-		'test/node/**/*',
-		'test/integration_tests/**/*',
-		'test/stub/**/*',
-		'test/stub/**/.*'
-	]
+    # A list of globs which match all files that should be packaged
+    # in the Phusion Passenger gem or tarball.
+    GLOB = [
+      '.gitignore',
+      '.travis.yml',
+      '.editorconfig',
+      'configure',
+      'Rakefile',
+      'Gemfile',
+      'Gemfile.lock',
+      'Vagrantfile',
+      'README.md',
+      'CONTRIBUTORS',
+      'CONTRIBUTING.md',
+      'LICENSE',
+      'CHANGELOG',
+      'INSTALL.md',
+      'NEWS',
+      'package.json',
+      'npm-shrinkwrap.json',
+      'passenger.gemspec',
+      'build/*.rb',
+      'lib/*.rb',
+      'lib/**/*.rb',
+      'lib/**/*.py',
+      'node_lib/**/*.js',
+      'bin/*',
+      'doc/**/*',
+      'man/*',
+      'debian.template/**/*',
+      'packaging/**/*',
+      'helper-scripts/**/*',
+      'ext/common/**/*.{cpp,c,h,hpp,md,erb}',
+      'ext/apache2/*.{cpp,h,hpp,c,erb}',
+      'ext/nginx/*.{c,cpp,h,erb}',
+      'ext/nginx/config',
+      'ext/boost/**/*',
+      'ext/libev/{LICENSE,Changes,README,Makefile.am,Makefile.in}',
+      'ext/libev/{*.m4,autogen.sh,config.guess,config.h.in,config.sub}',
+      'ext/libev/{configure,configure.ac,depcomp,install-sh,ltmain.sh,missing,mkinstalldirs}',
+      'ext/libev/{*.h,*.c}',
+      'ext/libeio/{LICENSE,Changes,README,Makefile.am,Makefile.in}',
+      'ext/libeio/{*.m4,autogen.sh,config.guess,config.h.in,config.sub}',
+      'ext/libeio/{configure,configure.ac,install-sh,ltmain.sh,missing,mkinstalldirs}',
+      'ext/libeio/{*.h,*.c}',
+      'ext/oxt/*.hpp',
+      'ext/oxt/*.cpp',
+      'ext/oxt/*.txt',
+      'ext/oxt/detail/*.hpp',
+      'ext/ruby/*.{c,rb}',
+      'dev/**/*',
+      'resources/**/*',
+      'test/.rspec',
+      'test/*.example',
+      'test/*.travis',
+      'test/*.rpm-automation',
+      'test/*.vagrant',
+      'test/*.supp',
+      'test/support/*.{c,cpp,h,rb}',
+      'test/tut/*',
+      'test/cxx/**/*.{cpp,h}',
+      'test/oxt/*.{cpp,hpp}',
+      'test/ruby/**/*',
+      'test/node/**/*',
+      'test/integration_tests/**/*',
+      'test/stub/**/*',
+      'test/stub/**/.*'
+    ]
 
-	EXCLUDE_GLOB = [
-		'**/.DS_Store',
-		'packaging/*/.git',
-		'test/stub/rails_apps/3.0/empty/help/**/*',
-		'test/stub/*.dSYM'
-	]
+    EXCLUDE_GLOB = [
+      '**/.DS_Store',
+      'packaging/*/.git',
+      'test/stub/rails_apps/3.0/empty/help/**/*',
+      'test/stub/*.dSYM'
+    ]
 
-	# Files that should be excluded from the Debian tarball.
-	DEBIAN_EXCLUDE_GLOB = [
-		"debian.template/**/*",
-		"packaging/**/*",
-	]
+    # Files that should be excluded from the Debian tarball.
+    DEBIAN_EXCLUDE_GLOB = [
+      "debian.template/**/*",
+      "packaging/**/*",
+    ]
 
-	# Files and directories that should be excluded from the Homebrew installation.
-	HOMEBREW_EXCLUDE = [
-		".gitignore", ".gitmodules", ".travis.yml", "package.json", "Vagrantfile",
-		"npm-shrinkwrap.json", "Gemfile", "Gemfile.lock", "debian.template",
-		"packaging", "dev", "test"
-	]
+    # Files and directories that should be excluded from the Homebrew installation.
+    HOMEBREW_EXCLUDE = [
+      ".gitignore", ".gitmodules", ".travis.yml", "package.json", "Vagrantfile",
+      "npm-shrinkwrap.json", "Gemfile", "Gemfile.lock", "debian.template",
+      "packaging", "dev", "test"
+    ]
 
-	def self.files
-		result = Dir[*GLOB] - Dir[*EXCLUDE_GLOB]
-		result.reject! { |path| path =~ %r{/\.\.?$} }
-		return result
-	end
+    def self.files
+      result = Dir[*GLOB] - Dir[*EXCLUDE_GLOB]
+      result.reject! { |path| path =~ %r{/\.\.?$} }
+      return result
+    end
 
-	def self.debian_orig_tarball_files
-		return files - Dir[*DEBIAN_EXCLUDE_GLOB]
-	end
-end
+    def self.debian_orig_tarball_files
+      return files - Dir[*DEBIAN_EXCLUDE_GLOB]
+    end
+  end
 
 end # module PhusionPassenger

data/lib/phusion_passenger/platform_info.rb

@@ -26,365 +26,365 @@ PhusionPassenger.require_passenger_lib 'utils/tmpio'
 
 module PhusionPassenger
 
-# This module autodetects various platform-specific information, and
-# provides that information through constants.
-module PlatformInfo
-private
-	@@cache_dir = nil
-	@@verbose   = ['1', 'true', 'on', 'yes'].include?(ENV['VERBOSE'])
-	@@log_implementation = lambda do |message|
-		message = reindent(message, 3)
-		message.sub!(/^   /, '')
-		STDERR.puts " * #{message}"
-	end
-	
-	def self.private_class_method(name)
-		metaclass = class << self; self; end
-		metaclass.send(:private, name)
-	end
-	private_class_method :private_class_method
-	
-	# Turn the specified class method into a memoized one. If the given
-	# class method is called without arguments, then its result will be
-	# memoized, frozen, and returned upon subsequent calls without arguments.
-	# Calls with arguments are never memoized.
-	#
-	# If +cache_to_disk+ is true and a cache directory has been set with
-	# <tt>PlatformInfo.cache_dir=</tt> then result is cached to a file on disk,
-	# so that memoized results persist over multiple process runs. This
-	# cache file expires in +cache_time+ seconds (1 hour by default) after
-	# it has been written.
-	#
-	#   def self.foo(max = 10)
-	#     rand(max)
-	#   end
-	#   memoize :foo
-	#   
-	#   foo        # => 3
-	#   foo        # => 3
-	#   foo(100)   # => 49
-	#   foo(100)   # => 26
-	#   foo        # => 3
-	def self.memoize(method, cache_to_disk = false, cache_time = 3600)
-	    # We use class_eval here because Ruby 1.8.5 doesn't support class_variable_get/set.
-	    metaclass = class << self; self; end
-	    metaclass.send(:alias_method, "_unmemoized_#{method}", method)
-	    variable_name = "@@memoized_#{method}".sub(/\?/, '')
-	    check_variable_name = "@@has_memoized_#{method}".sub(/\?/, '')
-	    eval(%Q{
-	      #{variable_name} = nil
-	      #{check_variable_name} = false
-	    })
-	    line = __LINE__ + 1
-	    source = %Q{
-	      def self.#{method}(*args)                                           # def self.httpd(*args)
-	        if args.empty?                                                    #   if args.empty?
-	          if !#{check_variable_name}                                      #     if !@@has_memoized_httpd
-	            if @@cache_dir                                                #       if @@cache_dir
-	              cache_file = File.join(@@cache_dir, "#{method}")            #         cache_file = File.join(@@cache_dir, "httpd")
-	            end                                                           #       end
-	            read_from_cache_file = false                                  #       read_from_cache_file = false
-	            if #{cache_to_disk} && cache_file && File.exist?(cache_file)  #       if #{cache_to_disk} && File.exist?(cache_file)
-	              cache_file_stat = File.stat(cache_file)                     #         cache_file_stat = File.stat(cache_file)
-	              read_from_cache_file =                                      #         read_from_cache_file =
-	                Time.now - cache_file_stat.mtime < #{cache_time}          #           Time.now - cache_file_stat.mtime < #{cache_time}
-	            end                                                           #       end
-	            if read_from_cache_file                                       #       if read_from_cache_file
-	              data = File.read(cache_file)                                #         data = File.read(cache_file)
-	              #{variable_name} = Marshal.load(data).freeze                #         @@memoized_httpd = Marshal.load(data).freeze
-	              #{check_variable_name} = true                               #         @@has_memoized_httpd = true
-	            else                                                          #       else
-	              #{variable_name} = _unmemoized_#{method}.freeze             #         @@memoized_httpd = _unmemoized_httpd.freeze
-	              #{check_variable_name} = true                               #         @@has_memoized_httpd = true
-	              if cache_file && #{cache_to_disk}                           #         if cache_file && #{cache_to_disk}
-	                begin                                                     #           begin
-	                  if !File.directory?(@@cache_dir)                        #             if !File.directory?(@@cache_dir)
-	                    Dir.mkdir(@@cache_dir)                                #               Dir.mkdir(@@cache_dir)
-	                  end                                                     #             end
-	                  File.open(cache_file, "wb") do |f|                      #             File.open(cache_file, "wb") do |f|
-	                    f.write(Marshal.dump(#{variable_name}))               #               f.write(Marshal.dump(@@memoized_httpd))
-	                  end                                                     #             end
-	                rescue Errno::EACCES                                      #           rescue Errno::EACCES
-	                  # Ignore permission error.                              #             # Ignore permission error.
-	                end                                                       #           end
-	              end                                                         #         end
-	            end                                                           #       end
-	          end                                                             #     end
-	          #{variable_name}                                                #     @@memoized_httpd
-	        else                                                              #   else
-	          _unmemoized_#{method}(*args)                                    #     _unmemoized_httpd(*args)
-	        end                                                               #   end
-	      end                                                                 # end
-	    }
-	    class_eval(source, __FILE__, line)
-	end
-	private_class_method :memoize
-	
-	# Look in the directory +dir+ and check whether there's an executable
-	# whose base name is equal to one of the elements in +possible_names+.
-	# If so, returns the full filename. If not, returns nil.
-	def self.select_executable(dir, *possible_names)
-		possible_names.each do |name|
-			filename = "#{dir}/#{name}"
-			if File.file?(filename) && File.executable?(filename)
-				return filename
-			end
-		end
-		return nil
-	end
-	private_class_method :select_executable
-
-	def self.unindent(str)
-		str = str.dup
-		str.gsub!(/\A([\s\t]*\n)+/, '')
-		str.gsub!(/[\s\t\n]+\Z/, '')
-		indent = str.split("\n").select{ |line| !line.strip.empty? }.map{ |line| line.index(/[^\s]/) }.compact.min || 0
-		str.gsub!(/^[[:blank:]]{#{indent}}/, '')
-		return str
-	end
-	private_class_method :unindent
-
-	def self.reindent(str, level)
-		str = unindent(str)
-		str.gsub!(/^/, ' ' * level)
-		return str
-	end
-	private_class_method :reindent
-
-	def self.create_temp_file(name, dir = tmpdir)
-		# This function is mostly used for compiling C programs to autodetect
-		# system properties. We create a secure temp subdirectory to prevent
-		# TOCTU attacks, especially because we don't know how the compiler
-		# handles this.
-		PhusionPassenger::Utils.mktmpdir("passenger.", dir) do |subdir|
-			filename = "#{subdir}/#{name}"
-			f = File.open(filename, "w")
-			begin
-				yield(filename, f)
-			ensure
-				f.close if !f.closed?
-			end
-		end
-	end
-	private_class_method :create_temp_file
-
-	def self.log(message)
-		if verbose?
-			@@log_implementation.call(message)
-		end
-	end
-	private_class_method :log
-
-public
-	class RuntimeError < ::RuntimeError
-	end
-
-
-	def self.cache_dir=(value)
-		@@cache_dir = value
-	end
-
-	def self.cache_dir
-		return @@cache_dir
-	end
-
-	def self.verbose=(val)
-		@@verbose = val
-	end
-
-	def self.verbose?
-		return @@verbose
-	end
-
-	def self.log_implementation=(impl)
-		@@log_implementation = impl
-	end
-
-	def self.log_implementation
-		return @@log_implementation
-	end
-
-
-	def self.env_defined?(name)
-		return !ENV[name].nil? && !ENV[name].empty?
-	end
-
-	def self.string_env(name, default_value = nil)
-		value = ENV[name]
-		if value.nil? || value.empty?
-			return default_value
-		else
-			return value
-		end
-	end
-
-	def self.read_file(filename)
-		return File.open(filename, "rb") do |f|
-			f.read
-		end
-	rescue
-		return ""
-	end
-	
-	def self.tmpdir
-		result = ENV['TMPDIR']
-		if result && !result.empty?
-			return result.sub(/\/+\Z/, '')
-		else
-			return '/tmp'
-		end
-	end
-	memoize :tmpdir
-	
-	# 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
-	memoize :tmpexedir
-
-	def self.rb_config
-		if defined?(::RbConfig)
-			return ::RbConfig::CONFIG
-		else
-			return ::Config::CONFIG
-		end
-	end
-
-	# 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
-
-	def self.find_all_commands(name)
-		search_dirs = ENV['PATH'].to_s.split(File::PATH_SEPARATOR)
-		search_dirs.concat(%w(/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
-		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
-end
+  # This module autodetects various platform-specific information, and
+  # provides that information through constants.
+  module PlatformInfo
+  private
+    @@cache_dir = nil
+    @@verbose   = ['1', 'true', 'on', 'yes'].include?(ENV['VERBOSE'])
+    @@log_implementation = lambda do |message|
+      message = reindent(message, 3)
+      message.sub!(/^   /, '')
+      STDERR.puts " * #{message}"
+    end
+
+    def self.private_class_method(name)
+      metaclass = class << self; self; end
+      metaclass.send(:private, name)
+    end
+    private_class_method :private_class_method
+
+    # Turn the specified class method into a memoized one. If the given
+    # class method is called without arguments, then its result will be
+    # memoized, frozen, and returned upon subsequent calls without arguments.
+    # Calls with arguments are never memoized.
+    #
+    # If +cache_to_disk+ is true and a cache directory has been set with
+    # <tt>PlatformInfo.cache_dir=</tt> then result is cached to a file on disk,
+    # so that memoized results persist over multiple process runs. This
+    # cache file expires in +cache_time+ seconds (1 hour by default) after
+    # it has been written.
+    #
+    #   def self.foo(max = 10)
+    #     rand(max)
+    #   end
+    #   memoize :foo
+    #
+    #   foo        # => 3
+    #   foo        # => 3
+    #   foo(100)   # => 49
+    #   foo(100)   # => 26
+    #   foo        # => 3
+    def self.memoize(method, cache_to_disk = false, cache_time = 3600)
+        # We use class_eval here because Ruby 1.8.5 doesn't support class_variable_get/set.
+        metaclass = class << self; self; end
+        metaclass.send(:alias_method, "_unmemoized_#{method}", method)
+        variable_name = "@@memoized_#{method}".sub(/\?/, '')
+        check_variable_name = "@@has_memoized_#{method}".sub(/\?/, '')
+        eval(%Q{
+          #{variable_name} = nil
+          #{check_variable_name} = false
+        })
+        line = __LINE__ + 1
+        source = %Q{
+          def self.#{method}(*args)                                           # def self.httpd(*args)
+            if args.empty?                                                    #   if args.empty?
+              if !#{check_variable_name}                                      #     if !@@has_memoized_httpd
+                if @@cache_dir                                                #       if @@cache_dir
+                  cache_file = File.join(@@cache_dir, "#{method}")            #         cache_file = File.join(@@cache_dir, "httpd")
+                end                                                           #       end
+                read_from_cache_file = false                                  #       read_from_cache_file = false
+                if #{cache_to_disk} && cache_file && File.exist?(cache_file)  #       if #{cache_to_disk} && File.exist?(cache_file)
+                  cache_file_stat = File.stat(cache_file)                     #         cache_file_stat = File.stat(cache_file)
+                  read_from_cache_file =                                      #         read_from_cache_file =
+                    Time.now - cache_file_stat.mtime < #{cache_time}          #           Time.now - cache_file_stat.mtime < #{cache_time}
+                end                                                           #       end
+                if read_from_cache_file                                       #       if read_from_cache_file
+                  data = File.read(cache_file)                                #         data = File.read(cache_file)
+                  #{variable_name} = Marshal.load(data).freeze                #         @@memoized_httpd = Marshal.load(data).freeze
+                  #{check_variable_name} = true                               #         @@has_memoized_httpd = true
+                else                                                          #       else
+                  #{variable_name} = _unmemoized_#{method}.freeze             #         @@memoized_httpd = _unmemoized_httpd.freeze
+                  #{check_variable_name} = true                               #         @@has_memoized_httpd = true
+                  if cache_file && #{cache_to_disk}                           #         if cache_file && #{cache_to_disk}
+                    begin                                                     #           begin
+                      if !File.directory?(@@cache_dir)                        #             if !File.directory?(@@cache_dir)
+                        Dir.mkdir(@@cache_dir)                                #               Dir.mkdir(@@cache_dir)
+                      end                                                     #             end
+                      File.open(cache_file, "wb") do |f|                      #             File.open(cache_file, "wb") do |f|
+                        f.write(Marshal.dump(#{variable_name}))               #               f.write(Marshal.dump(@@memoized_httpd))
+                      end                                                     #             end
+                    rescue Errno::EACCES                                      #           rescue Errno::EACCES
+                      # Ignore permission error.                              #             # Ignore permission error.
+                    end                                                       #           end
+                  end                                                         #         end
+                end                                                           #       end
+              end                                                             #     end
+              #{variable_name}                                                #     @@memoized_httpd
+            else                                                              #   else
+              _unmemoized_#{method}(*args)                                    #     _unmemoized_httpd(*args)
+            end                                                               #   end
+          end                                                                 # end
+        }
+        class_eval(source, __FILE__, line)
+    end
+    private_class_method :memoize
+
+    # Look in the directory +dir+ and check whether there's an executable
+    # whose base name is equal to one of the elements in +possible_names+.
+    # If so, returns the full filename. If not, returns nil.
+    def self.select_executable(dir, *possible_names)
+      possible_names.each do |name|
+        filename = "#{dir}/#{name}"
+        if File.file?(filename) && File.executable?(filename)
+          return filename
+        end
+      end
+      return nil
+    end
+    private_class_method :select_executable
+
+    def self.unindent(str)
+      str = str.dup
+      str.gsub!(/\A([\s\t]*\n)+/, '')
+      str.gsub!(/[\s\t\n]+\Z/, '')
+      indent = str.split("\n").select{ |line| !line.strip.empty? }.map{ |line| line.index(/[^\s]/) }.compact.min || 0
+      str.gsub!(/^[[:blank:]]{#{indent}}/, '')
+      return str
+    end
+    private_class_method :unindent
+
+    def self.reindent(str, level)
+      str = unindent(str)
+      str.gsub!(/^/, ' ' * level)
+      return str
+    end
+    private_class_method :reindent
+
+    def self.create_temp_file(name, dir = tmpdir)
+      # This function is mostly used for compiling C programs to autodetect
+      # system properties. We create a secure temp subdirectory to prevent
+      # TOCTU attacks, especially because we don't know how the compiler
+      # handles this.
+      PhusionPassenger::Utils.mktmpdir("passenger.", dir) do |subdir|
+        filename = "#{subdir}/#{name}"
+        f = File.open(filename, "w")
+        begin
+          yield(filename, f)
+        ensure
+          f.close if !f.closed?
+        end
+      end
+    end
+    private_class_method :create_temp_file
+
+    def self.log(message)
+      if verbose?
+        @@log_implementation.call(message)
+      end
+    end
+    private_class_method :log
+
+  public
+    class RuntimeError < ::RuntimeError
+    end
+
+
+    def self.cache_dir=(value)
+      @@cache_dir = value
+    end
+
+    def self.cache_dir
+      return @@cache_dir
+    end
+
+    def self.verbose=(val)
+      @@verbose = val
+    end
+
+    def self.verbose?
+      return @@verbose
+    end
+
+    def self.log_implementation=(impl)
+      @@log_implementation = impl
+    end
+
+    def self.log_implementation
+      return @@log_implementation
+    end
+
+
+    def self.env_defined?(name)
+      return !ENV[name].nil? && !ENV[name].empty?
+    end
+
+    def self.string_env(name, default_value = nil)
+      value = ENV[name]
+      if value.nil? || value.empty?
+        return default_value
+      else
+        return value
+      end
+    end
+
+    def self.read_file(filename)
+      return File.open(filename, "rb") do |f|
+        f.read
+      end
+    rescue
+      return ""
+    end
+
+    def self.tmpdir
+      result = ENV['TMPDIR']
+      if result && !result.empty?
+        return result.sub(/\/+\Z/, '')
+      else
+        return '/tmp'
+      end
+    end
+    memoize :tmpdir
+
+    # 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
+    memoize :tmpexedir
+
+    def self.rb_config
+      if defined?(::RbConfig)
+        return ::RbConfig::CONFIG
+      else
+        return ::Config::CONFIG
+      end
+    end
+
+    # 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
+
+    def self.find_all_commands(name)
+      search_dirs = ENV['PATH'].to_s.split(File::PATH_SEPARATOR)
+      search_dirs.concat(%w(/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
+      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
+  end
 
 end # module PhusionPassenger