#{h passenger_ruby} option to #{h ruby}. " \
'However, because you are using RVM, this is not allowed: the option must point to ' \
'an RVM wrapper script, not a raw Ruby binary. This is because RVM is implemented ' \
"through various environment variables, which are set through the wrapper script.\n",
:solution_description_html =>
"To find out the correct value for #{h passenger_ruby}, please read " \
"its documentation entry."
)
abort
end
end
def is_ruby_program?(path)
File.open(path, "rb") do |f|
f.readline =~ /ruby/
end
rescue EOFError
false
end
def exit_code_for_exception(e)
if e.is_a?(SystemExit)
e.status
else
1
end
end
def load_macos_foundation
# Apple added an assertion in 10.13 that prevents anything Obj-C related
# from occuring between fork and exec. This workaround prevents the assertion.
# http://www.sealiesoftware.com/blog/archive/2017/6/5/Objective-C_and_fork_in_macOS_1013.html
# https://github.com/puma/puma/issues/1421
if PlatformInfo::RUBY_ENGINE == 'ruby' && PlatformInfo.os_name_simple == "macosx"
# Eager-load Foundation.framework, to ensure the Objective-C runtime
# exists well before any forking happens
begin
require 'fiddle'
rescue LoadError
return
end
if Fiddle.respond_to?(:dlopen)
begin
Fiddle.dlopen '/System/Library/Frameworks/Foundation.framework/Foundation'
rescue Fiddle::DLError => e
STDERR.puts "WARNING: #{e}"
end
end
end
end
# Prepare an application process using rules for the given spawn options.
# This method is to be called before loading the application code.
#
# +startup_file+ is the application type's startup file, e.g.
# "config/environment.rb" for Rails apps and "config.ru" for Rack apps.
# +options+ are the spawn options that were given.
#
# This function may modify +options+. The modified options are to be
# passed to the request handler.
def before_loading_app_code_step1(startup_file, options)
DebugLogging.log_level = options["log_level"] if options["log_level"]
end
def run_load_path_setup_code(options)
# rack-preloader.rb depends on the 'rack' library, but the app
# might want us to use a bundled version instead of a
# gem/apt-get/yum/whatever-installed version. Therefore we must setup
# the correct load paths before requiring 'rack'.
#
# The most popular tool for bundling dependencies is Bundler. Bundler
# works as follows:
# - If the bundle is locked then a file .bundle/environment.rb exists
# which will setup the load paths.
# - If the bundle is not locked then the load paths must be set up by
# calling Bundler.setup.
# - Rails 3's boot.rb automatically loads .bundle/environment.rb or
# calls Bundler.setup if that's not available.
# - Other Rack apps might not have a boot.rb but we still want to setup
# Bundler.
# - Some Rails 2 apps might have explicitly added Bundler support.
# These apps call Bundler.setup in their preinitializer.rb.
#
# So the strategy is as follows:
# Our strategy might be completely unsuitable for the app or the
# developer is using something other than Bundler, so we let the user
# manually specify a load path setup file.
if options["load_path_setup_file"]
require File.expand_path(options["load_path_setup_file"])
# The app developer may also override our strategy with this magic file.
elsif File.exist?('config/setup_load_paths.rb')
require File.expand_path('config/setup_load_paths')
# Older versions of Bundler use .bundle/environment.rb as the Bundler
# environment lock file. This has been replaced by Gemfile.lock/gems.locked
# in later versions, but we still support the older mechanism.
# If the Bundler environment lock file exists then load that. If it
# exists then there's a 99.9% chance that loading it is the correct
# thing to do.
elsif File.exist?('.bundle/environment.rb')
running_bundler(options) do
require File.expand_path('.bundle/environment')
end
# If the legacy Bundler environment file doesn't exist then there are two
# possibilities:
# 1. Bundler is not used, in which case we don't have to do anything.
# 2. Bundler *is* used, but either the user is using a newer Bundler versions,
# or the gems are not locked. In either case, we're supposed to call
# Bundler.setup.
#
# The existence of Gemfile/gems.rb indicates whether (2) is true:
elsif File.exist?('Gemfile') || File.exist?('gems.rb')
# In case of Rails 3+, config/boot.rb already calls Bundler.setup.
# However older versions of Rails may not so loading boot.rb might
# not be the correct thing to do. To be on the safe side we
# call Bundler.setup ourselves; calling Bundler.setup twice is
# harmless. If this isn't the correct thing to do after all then
# there's always the load_path_setup_file option and
# setup_load_paths.rb.
running_bundler(options) do
activate_gem 'bundler', 'bundler/setup'
end
end
# !!! NOTE !!!
# If the app is using Bundler then any dependencies required past this
# point must be specified in the Gemfile. Like ruby-debug if debugging is on...
end
# This method is to be called after the load path has been set up
# (e.g. Bundler.setup is called), but before loading the app code.
def before_loading_app_code_step2(options)
# Do nothing
end
# This method is to be called after loading the application code but
# before forking a worker process.
def after_loading_app_code(options)
end
# If the current working directory equals `app_root`, and `abs_path` is a
# file inside `app_root`, then returns its basename. Otherwise, returns
# `abs_path`.
#
# The main use case for this method is to ensure that we load config.ru
# with a relative path (only its base name) in most circumstances,
# instead of with an absolute path. This is necessary in order to retain
# compatibility with apps that expect config.ru's __FILE__ to be relative.
# See https://github.com/phusion/passenger/issues/1596
def maybe_make_path_relative_to_app_root(app_root, abs_path)
if Dir.logical_pwd == app_root && File.dirname(abs_path) == app_root
File.basename(abs_path)
else
abs_path
end
end
def create_socket_address(protocol, address)
if protocol == 'unix'
"unix:#{address}"
elsif protocol == 'tcp'
"tcp://#{address}"
else
raise ArgumentError, "Unknown protocol '#{protocol}'"
end
end
def advertise_sockets(_options, request_handler)
json = { :sockets => [] }
request_handler.server_sockets.each_pair do |name, options|
concurrency = PhusionPassenger.advertised_concurrency_level || options[:concurrency]
json[:sockets] << {
:name => name,
:address => options[:address],
:protocol => options[:protocol],
:concurrency => concurrency,
:accept_http_requests => !!options[:accept_http_requests]
}
end
File.open(ENV['PASSENGER_SPAWN_WORK_DIR'] + '/response/properties.json', 'w') do |f|
f.write(PhusionPassenger::Utils::JSON.generate(json))
end
end
def advertise_readiness(options)
File.open(ENV['PASSENGER_SPAWN_WORK_DIR'] + '/response/finish', 'w') do |f|
f.write('1')
end
end
# To be called before the request handler main loop is entered, but after the app
# startup file has been loaded. This function will fire off necessary events
# and perform necessary preparation tasks.
#
# +forked+ indicates whether the current worker process is forked off from
# an ApplicationSpawner that has preloaded the app code.
# +options+ are the spawn options that were passed.
def before_handling_requests(forked, options)
if forked
# Reseed pseudo-random number generator for security reasons.
srand
end
if options["process_title"] && !options["process_title"].empty?
$0 = options["process_title"] + ": " + options["app_group_name"]
end
# If we were forked from a preloader process then clear or
# re-establish ActiveRecord database connections. This prevents
# child processes from concurrently accessing the same
# database connection handles.
if forked && defined?(ActiveRecord::Base)
if ActiveRecord::Base.respond_to?(:clear_all_connections!)
ActiveRecord::Base.clear_all_connections!
elsif ActiveRecord::Base.respond_to?(:clear_active_connections!)
ActiveRecord::Base.clear_active_connections!
end
ActiveRecord::Base.establish_connection
end
# Fire off events.
PhusionPassenger.call_event(:starting_worker_process, forked)
if options["pool_account_username"] && options["pool_account_password_base64"]
password = options["pool_account_password_base64"].unpack('m').first
PhusionPassenger.call_event(:credentials,
options["pool_account_username"], password)
else
PhusionPassenger.call_event(:credentials, nil, nil)
end
end
# To be called after the request handler main loop is exited. This function
# will fire off necessary events perform necessary cleanup tasks.
def after_handling_requests
PhusionPassenger.call_event(:stopping_worker_process)
end
# Activate a gem and require it. This method exists in order to load
# a library from RubyGems instead of from vendor_ruby. For example,
# on Debian systems, Rack may be installed from APT, but that is usually
# a very old version which we don't want. This method ensures that the
# RubyGems-installed version is loaded, not the the version in vendor_ruby.
# See the following threads for discussion:
# https://github.com/phusion/passenger/issues/1478
# https://github.com/phusion/passenger/issues/1480
def activate_gem(gem_name, library_name = nil)
if !defined?(::Gem)
begin
require 'rubygems'
rescue LoadError
end
end
if Kernel.respond_to?(:gem, true)
begin
gem(gem_name)
rescue Gem::LoadError
end
end
require(library_name || gem_name)
end
##### Journey recording #####
def record_journey_step_begin(step, state, *args)
@main_app.record_journey_step_begin(step, state, *args)
end
def record_journey_step_end(step, state, *args)
@main_app.record_journey_step_end(step, state, *args)
end
def run_block_and_record_step_progress(step, *args)
record_journey_step_begin(step, 'STEP_IN_PROGRESS', *args)
begin
yield
rescue Exception => e
record_journey_step_end(step, 'STEP_ERRORED', *args)
raise e
else
record_journey_step_end(step, 'STEP_PERFORMED', *args)
end
end
##### Error reporting #####
# To be called whenever the (pre)loader is about to abort with an error.
def about_to_abort(options, exception)
dump_all_information(options)
end
def record_and_print_exception(e)
record_error_category_based_on_exception(e)
record_and_print_error_summary(
"The application encountered the following error: #{e} (#{e.class})")
STDERR.write(" #{e.backtrace.join("\n ")}\n")
record_advanced_problem_details(format_exception(e))
if e.respond_to?(:problem_description_html)
record_problem_description_html(e.problem_description_html)
end
if e.respond_to?(:solution_description_html)
record_solution_description_html(e.solution_description_html)
end
end
def record_error_category(category)
dir = ENV['PASSENGER_SPAWN_WORK_DIR']
try_write_file("#{dir}/response/error/category", category)
end
def record_error_category_based_on_exception(e)
if e.is_a?(IOError)
record_error_category('IO_ERROR')
elsif e.is_a?(SystemCallError)
record_error_category('OPERATING_SYSTEM_ERROR')
else
record_error_category('INTERNAL_ERROR')
end
end
def record_error_summary(summary)
dir = ENV['PASSENGER_SPAWN_WORK_DIR']
try_write_file("#{dir}/response/error/summary", summary)
end
def record_and_print_error_summary(summary)
STDERR.puts "Error: #{summary}"
record_error_summary(summary)
end
def record_advanced_problem_details(message)
dir = ENV['PASSENGER_SPAWN_WORK_DIR']
try_write_file("#{dir}/response/error/advanced_problem_details", message)
end
def record_problem_description_html(html)
dir = ENV['PASSENGER_SPAWN_WORK_DIR']
try_write_file("#{dir}/response/error/problem_description.html", html)
end
def record_solution_description_html(html)
dir = ENV['PASSENGER_SPAWN_WORK_DIR']
try_write_file("#{dir}/response/error/solution_description.html", html)
end
def format_exception(e)
result = "#{e} (#{e.class})"
if !e.backtrace.empty?
result << "\n " << e.backtrace.join("\n ")
end
result
end
##### Environment dumping #####
def dump_all_information(options)
dump_ruby_environment
dump_envvars
end
def dump_ruby_environment
dir = "#{ENV['PASSENGER_SPAWN_WORK_DIR']}/envdump/annotations"
File.open("#{dir}/ruby_info", "w") do |f|
f.puts "RUBY_VERSION = #{RUBY_VERSION}"
f.puts "RUBY_PLATFORM = #{RUBY_PLATFORM}"
f.puts "RUBY_ENGINE = #{defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'nil'}"
end
File.open("#{dir}/load_path", "wb") do |f|
$LOAD_PATH.each do |path|
f.puts path
end
end
File.open("#{dir}/loaded_libs", "wb") do |f|
$LOADED_FEATURES.each do |filename|
f.puts filename
end
end
# We write to these files last because the 'require' calls can fail.
require 'rbconfig' if !defined?(RbConfig::CONFIG)
File.open("#{dir}/rbconfig", "wb") do |f|
RbConfig::CONFIG.each_pair do |key, value|
f.puts "#{key} = #{value}"
end
end
begin
require 'rubygems' if !defined?(Gem)
rescue LoadError
end
if defined?(Gem)
File.open("#{dir}/ruby_info", "a") do |f|
f.puts "RubyGems version = #{Gem::VERSION}"
if Gem.respond_to?(:path)
f.puts "RubyGems paths = #{Gem.path.inspect}"
else
f.puts "RubyGems paths = unknown; incompatible RubyGems API"
end
end
File.open("#{dir}/activated_gems", "wb") do |f|
if Gem.respond_to?(:loaded_specs)
Gem.loaded_specs.each_pair do |name, spec|
f.puts "#{name} => #{spec.version}"
end
else
f.puts "Unable to query this information; incompatible RubyGems API."
end
end
end
rescue SystemCallError
# Don't care.
end
def dump_envvars
dir = "#{ENV['PASSENGER_SPAWN_WORK_DIR']}/envdump"
try_write_file("#{dir}/envvars", ENV.to_a.map { |k, v| "#{k} = #{v}" }.join("\n"))
end
private
def running_bundler(options)
yield
rescue Exception => e
if (defined?(Bundler::GemNotFound) && e.is_a?(Bundler::GemNotFound)) ||
(defined?(Bundler::GitError) && e.is_a?(Bundler::GitError))
ruby = PlatformInfo.ruby_command
e_as_str = "#{e}" # Certain classes like Interrupt don't like #to_s, so we use this
if Bundler.respond_to?(:settings) && Bundler.settings.respond_to?(:path)
bundle_path = Bundler.settings.path
end
case options['integration_mode']
when 'apache'
passenger_ruby = 'PassengerRuby'
passenger_ruby_doc = 'https://www.phusionpassenger.com/library/config/apache/reference/#passengerruby'
passenger_user = 'PassengerUser'
passenger_user_doc = 'https://www.phusionpassenger.com/library/config/apache/reference/#passengeruser'
when 'nginx'
passenger_ruby = 'passenger_ruby'
passenger_ruby_doc = 'https://www.phusionpassenger.com/library/config/nginx/reference/#passenger_ruby'
passenger_user = 'passenger_user'
passenger_user_doc = 'https://www.phusionpassenger.com/library/config/nginx/reference/#passenger_user'
when 'standalone'
passenger_ruby = '--ruby'
passenger_ruby_doc = 'https://www.phusionpassenger.com/library/config/standalone/reference/#--ruby-ruby'
else
raise "Unknown integration mode #{options['integration_mode'].inspect}"
end
problem_description = %Q{
| Most common causes | Solution finder |
|---|---|
| You may not have installed all the gems that this application needs. | Read solution |
|
Run the following from the application directory: bundle install |
|
|
If the necessary gems are installed, but Bundler may not have
permissions to access them.
}
if bundle_path
problem_description << %Q{
Bundler tried to load the gems from #{h bundle_path}.
}
end
problem_description << %Q{
|
Read solution |
|
#{
check_execution_environment_solution_description(
passenger_user, passenger_user_doc, bundle_path)
}
|
|
|
The application may be run under the wrong user account or execution
environment.
It is currently running as #{h whoami}.
|
Read solution |
|
#{
check_execution_environment_solution_description(
passenger_user, passenger_user_doc, bundle_path)
}
|
|
|
The application may be run under the wrong Ruby interpreter.
It is currently being run under #{h ruby}.
|
Read solution |
|
Use the #{h passenger_ruby}
setting to change the Ruby interpreter that #{PROGRAM_NAME} uses.
|
|
|
The application may be run under the wrong RVM gemset.
It is currently running under the #{h PlatformInfo.rvm_ruby_string} gemset.
|
Read solution |
|
Use the #{h passenger_ruby}
setting. The documentation for that setting will teach you how to
refer to the proper gemset.
|
|
|
You are using a system-wide-installed RVM Ruby installation.
It is possible that, at the same time, your gems are installed
to the home directory (#{h home_dir}/.rvm/gems). If this is the
case then RVM will not be able to use those gems.
You are currently using this Ruby interpreter: #{h ruby}
|
Read solution |
|
To make Bundler and RVM able to load gems from the home directory, set #{h passenger_ruby} to an RVM wrapper script inside the home directory:
|
|
| The RVM gemset may be broken. | Read solution |
Exception message:
#{h e_as_str} (#{h e.class.to_s})
Backtrace:
#{h e.backtrace.join("\n")}
}
attach_problem_description_html_to_exception(e, problem_description)
solution_description =
"Run the following from the application directory:
" \ "bundle install" \ \ "
Is the application running under the expected execution environment?" \
" A common problem is that the application runs under a different user than" \
" it is supposed to. The application is currently running as the #{h whoami}" \
" user — is this expected? Also, check the 'Detailed diagnostics'" \
" » 'Subprocess' tab and double check all information there — is" \
" everything as expected? If not, please fix that.
If the application is not supposed to run as #{h whoami}," \
" then you can configure this via the" \
" #{h passenger_user}" \
" setting.
Please check whether the application, which is running as the" \
" #{h whoami} user, has permissions to access"
if bundle_path
solution_description <<
" #{h bundle_path}."
else
solution_description <<
" the directory that Bundler tries to load gems from. Unfortunately" \
" #{SHORT_PROGRAM_NAME} was unable to figure out which directory this"
" is because Bundler is too old, so you need to figure out the" \
" directory yourself (or you can upgrade Bundler so that #{SHORT_PROGRAM_NAME}" \
" can figure out the path for you)."
end
solution_description <<
"
Is the application supposed to be run with #{h ruby}?" \
" If not, please change the #{h passenger_ruby}" \
" setting.
Is the application supposed to run under the #{h PlatformInfo.rvm_ruby_string}" \
" gemset? If not, please change the #{h passenger_ruby}" \
" setting. The documentation for that setting will teach you how to refer" \
" to the proper gemset.
Your Ruby interpreter is installed by RVM in a system-wide manner: it is" \
" located in #{h ruby}. If Bundler tries to load gems from " \
"#{h home_dir}/.rvm/gems, then that won't work.
To make Bundler and RVM able to load gems from the home directory, set " \ "#{h passenger_ruby} to an RVM wrapper script " \ "inside the home directory:
\n\n" \ "rvm user gemsets
#{h PlatformInfo.ruby_command} \\\n" \
"#{PhusionPassenger.bin_dir}/passenger-config about ruby-commandSometimes, RVM gemsets maybe be broken. " \ "" \ "Try resetting them.
" end attach_solution_description_html_to_exception(e, solution_description) end raise e end def check_execution_environment_solution_description(passenger_user, passenger_user_doc, bundle_path) result = '' result << %Q{
Is the application running under the expected execution environment?
A common problem is that the application runs under a different user than
it is supposed to. The application is currently running as the #{h whoami}
user — is this expected? Also, check the 'Detailed diagnostics'
» 'Subprocess' tab and double check all information there — is
everything as expected?
If the application is not supposed to run as #{h whoami},
then you can configure this via the
#{h passenger_user}
setting.
Please check whether the application, which is running as the
#{h whoami} user, has permissions to access
}
if bundle_path
result << %Q{
#{h bundle_path}.
}
else
result << %Q{
the directory that Bundler tries to load gems from. Unfortunately
#{SHORT_PROGRAM_NAME} was unable to figure out which directory this
is because Bundler is too old, so you need to figure out the
directory yourself (or you can upgrade Bundler so that #{SHORT_PROGRAM_NAME}
can figure out the path for you).
}
end
result << %Q{