Current File : //opt/cpanel/ea-ruby27/src/passenger-release-6.0.23/test/support/apache2_controller.rb
require 'erb'
require 'fileutils'
require 'time'
PhusionPassenger.require_passenger_lib 'platform_info/apache'
PhusionPassenger.require_passenger_lib 'platform_info/ruby'
# A class for starting, stopping and restarting Apache, and for manipulating
# its configuration file. This is used by the integration tests.
#
# Before a test begins, the test instructs Apache2Controller to create an Apache
# configuration folder, which contains an Apache configuration file and other
# configuration resources that Apache needs. The Apache configuration file is
# created from a template (see Apache2Controller::STUB_DIR).
# The test can define configuration customizations. For example, it can tell
# Apache2Controller to add configuration options, virtual host definitions, etc.
#
# After the configuration folder has been created, Apache2Controller will start
# Apache. After Apache has been started, the test will be run. Apache2Controller
# will stop Apache after the test is done.
#
# Apache2Controller ensures that starting, stopping and restarting are not prone
# to race conditions. For example, it ensures that when #start returns, Apache
# really is listening on its server socket instead of still initializing.
#
# == Usage
#
# Suppose that you want to test a hypothetical "AlwaysPrintHelloWorld"
# Apache configuration option. Then you can write the following test:
#
# apache = Apache2Controller.new
#
# # Add a configuration option to the configuration file.
# apache << "AlwaysPrintHelloWorld on"
#
# # Write configuration file and start Apache with that configuration file.
# apache.start
#
# begin
# response_body = http_get("http://localhost:#{apache.port}/some/url")
# response_body.should == "hello world!"
# ensure
# apache.stop
# end
class Apache2Controller
include PhusionPassenger
STUB_DIR = File.expand_path(File.dirname(__FILE__) + "/../stub/apache2")
class VHost
attr_accessor :domain
attr_accessor :document_root
attr_accessor :additional_configs
def initialize(domain, document_root)
@domain = domain
@document_root = document_root
@additional_configs = []
end
def <<(config)
@additional_configs << config
end
end
attr_accessor :port
attr_accessor :vhosts
attr_reader :server_root
def initialize(options = nil)
set(options) if options
@port ||= 64506
@vhosts = []
@extra = []
@server_root = File.expand_path('tmp.apache2')
@passenger_root = File.expand_path(PhusionPassenger.install_spec)
@mod_passenger = PhusionPassenger.apache2_module_path
end
def set(options)
options.each_pair do |key, value|
instance_variable_set("@#{key}", value)
end
end
# Create an Apache configuration folder and start Apache on that
# configuration folder. This method does not return until Apache
# has done initializing.
#
# If Apache is already started, this this method will stop Apache first.
def start
if running?
stop
else
File.unlink("#{@server_root}/httpd.pid") rescue nil
end
if @codesigning_identity
require 'open3'
stdout, stderr, status = Open3.capture3("codesign", "--force", "-s", @codesigning_identity, "--keychain", File.expand_path("~/Library/Keychains/login.keychain-db"), @mod_passenger)
if !status.success?
raise "Could not sign Apache module at #{@mod_passenger} with authority #{@codesigning_identity}: #{stderr}"
end
end
if File.exist?(@server_root)
FileUtils.rm_r(@server_root)
end
FileUtils.mkdir_p(@server_root)
write_config_file
FileUtils.cp("#{STUB_DIR}/mime.types", @server_root)
command = [PlatformInfo.httpd, "-f", "#{@server_root}/httpd.conf", "-k", "start"]
if boolean_option('VALGRIND')
command = ['valgrind', '--dsymutil=yes', '--vgdb=yes',
'--vgdb-error=1', '--trace-children=no'] + command
end
prev_error_log_position = error_log_position
if !system(*command)
raise [
"Could not start an Apache server: #{$?}",
"\t---------------- Begin logs -------------------",
read_error_log_starting_from(prev_error_log_position).split("\n").map{ |l| "\t#{l}" }.join("\n"),
"\t---------------- End logs -------------------",
].join("\n")
end
# Wait until the PID file has been created.
wait_start_time = Time.now
begin
Timeout::timeout(20) do
while !File.exist?("#{@server_root}/httpd.pid")
sleep(0.1)
end
end
rescue Timeout::Error
end_start_time = Time.now
raise [
"Timeout waiting for an Apache server report its PID:",
"\t---------------- Begin logs -------------------",
read_error_log_starting_from(prev_error_log_position).split("\n").map{ |l| "\t#{l}" }.join("\n"),
"\t---------------- End logs -------------------",
"Started waiting at #{wait_start_time.iso8601(3)}",
" Ended waiting at #{end_start_time.iso8601(3)}",
].join("\n")
end
# Wait until Apache is listening on the server port.
wait_start_time = Time.now
begin
Timeout::timeout(30) do
done = false
while !done
begin
socket = TCPSocket.new('localhost', @port)
socket.close
done = true
rescue Errno::ECONNREFUSED
sleep(0.1)
end
end
end
rescue Timeout::Error
end_start_time = Time.now
raise [
"Timeout waiting for an Apache server to listen on port #{@port}:",
"\t---------------- Begin logs -------------------",
read_error_log_starting_from(prev_error_log_position).split("\n").map{ |l| "\t#{l}" }.join("\n"),
"\t---------------- End logs -------------------",
"Started waiting at #{wait_start_time.iso8601(3)}",
" Ended waiting at #{end_start_time.iso8601(3)}",
].join("\n")
end
Dir["#{@server_root}/*"].each do |filename|
if File.file?(filename)
File.chmod(0666, filename)
end
end
end
def graceful_restart
write_config_file
if !system(PlatformInfo.httpd, "-f", "#{@server_root}/httpd.conf", "-k", "graceful")
raise "Cannot restart Apache."
end
end
# Stop Apache and delete its configuration folder. This method waits
# until Apache is done with its shutdown procedure.
#
# This method does nothing if Apache is already stopped.
def stop
pid_file = "#{@server_root}/httpd.pid"
if File.exist?(pid_file)
begin
pid = File.read(pid_file).strip.to_i
Process.kill('SIGTERM', pid)
rescue Errno::ESRCH
# Looks like a stale pid file.
FileUtils.rm_r(@server_root)
return
end
end
begin
# Wait until the PID file is removed.
Timeout::timeout(17) do
while File.exist?(pid_file)
sleep(0.1)
end
end
# Wait until the server socket is closed.
Timeout::timeout(7) do
done = false
while !done
begin
socket = TCPSocket.new('localhost', @port)
socket.close
sleep(0.1)
rescue SystemCallError
done = true
end
end
end
rescue Timeout::Error
raise "Unable to stop Apache."
end
if File.exist?(@server_root)
FileUtils.chmod_R(0777, @server_root)
FileUtils.rm_r(@server_root)
end
end
# Define a virtual host configuration block for the Apache configuration
# file. If there was already a vhost definition with the same domain name,
# then it will be overwritten.
#
# The given document root will be created if it doesn't exist.
def set_vhost(domain, document_root)
FileUtils.mkdir_p(document_root)
vhost = VHost.new(domain, document_root)
if block_given?
yield vhost
end
vhosts.reject! {|host| host.domain == domain}
vhosts << vhost
end
# Checks whether this Apache instance is running.
def running?
if File.exist?("#{@server_root}/httpd.pid")
pid = File.read("#{@server_root}/httpd.pid").strip
begin
Process.kill(0, pid.to_i)
return true
rescue Errno::ESRCH
return false
rescue SystemCallError
return true
end
else
return false
end
end
# Defines a configuration snippet to be added to the Apache configuration file.
def <<(line)
@extra << line
end
private
def get_binding
return binding
end
def write_config_file
template = ERB.new(File.read("#{STUB_DIR}/httpd.conf.erb"))
File.open("#{@server_root}/httpd.conf", 'w') do |f|
f.write(template.result(get_binding))
end
end
def error_log_position
if @log_file
File.open(@log_file, 'rb') do |f|
f.seek(0, IO::SEEK_END)
f.pos
end
end
rescue Errno::ENOENT
nil
end
def read_error_log_starting_from(prev_pos)
File.open(@log_file, 'r:utf-8') do |f|
f.seek(prev_pos || 0, IO::SEEK_SET)
f.read
end
rescue Errno::ENOENT
"(no log file)"
end
def modules_dir
PlatformInfo.apache2_modulesdir
end
def builtin_modules
@@builtin_modules ||= `#{PlatformInfo.httpd} -l`.split("\n").grep(/\.c$/).map do |line|
line.strip
end
end
def has_builtin_module?(name)
return builtin_modules.include?(name)
end
def has_module?(name)
return File.exist?("#{modules_dir}/#{name}")
end
def we_are_root?
return Process.uid == 0
end
def boolean_option(name, default_value = false)
value = ENV[name]
if value.nil? || value.empty?
default_value
else
value == "yes" || value == "on" || value == "true" || value == "1"
end
end
end
Mini Shell