Gam

??? 123123123123 ..................................................................................................................................... Gam

File manager - Edit - /opt/cpanel/ea-ruby27/root/usr/share/passenger/phusion_passenger/loader_shared_helpers.rb

Back
# encoding: binary # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2011-2025 Asynchronous B.V. # # "Passenger", "Phusion Passenger" and "Union Station" are registered # trademarks of Asynchronous B.V. # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN # THE SOFTWARE. module PhusionPassenger # Provides shared functions for loader and preloader apps. module LoaderSharedHelpers extend self # To be called by the (pre)loader as soon as possible. def init(main_app) @main_app = main_app options = read_startup_arguments # We don't dump PATH info because at this point it's # unlikely to be changed. dump_ruby_environment check_rvm_using_wrapper_script(options) PhusionPassenger.require_passenger_lib 'native_support' if defined?(NativeSupport) NativeSupport.disable_stdio_buffering end PhusionPassenger.require_passenger_lib 'constants' PhusionPassenger.require_passenger_lib 'public_api' PhusionPassenger.require_passenger_lib 'debug_logging' PhusionPassenger.require_passenger_lib 'platform_info/ruby' PhusionPassenger.require_passenger_lib 'platform_info/operating_system' PhusionPassenger.require_passenger_lib 'utils/shellwords' PhusionPassenger.require_passenger_lib 'ruby_core_enhancements' PhusionPassenger.require_passenger_lib 'ruby_core_io_enhancements' PhusionPassenger.require_passenger_lib 'request_handler' PhusionPassenger.require_passenger_lib 'rack/thread_handler_extension' RequestHandler::ThreadHandler.send(:include, Rack::ThreadHandlerExtension) Thread.main[:name] = "Main thread" load_macos_foundation options rescue Exception => e record_journey_step_end('SUBPROCESS_WRAPPER_PREPARATION', 'STEP_ERRORED') record_and_print_exception(e) exit exit_code_for_exception(e) end def read_startup_arguments work_dir = ENV['PASSENGER_SPAWN_WORK_DIR'] PhusionPassenger.require_passenger_lib 'utils/json' @@options = File.open("#{work_dir}/args.json", 'rb') do \|f\| PhusionPassenger::Utils::JSON.parse(f.read) end end def check_rvm_using_wrapper_script(options) ruby = options["ruby"] if ruby =~ %r(/\.?rvm/) && ruby =~ %r(/bin/ruby$) case options["integration_mode"] \|\| DEFAULT_INTEGRATION_MODE when "nginx" passenger_ruby = "passenger_ruby" passenger_ruby_doc = "https://www.phusionpassenger.com/library/config/nginx/reference/#setting_correct_passenger_ruby_value" when "apache" passenger_ruby = "PassengerRuby" passenger_ruby_doc = "https://www.phusionpassenger.com/library/config/apache/reference/#setting_correct_passenger_ruby_value" when "standalone" passenger_ruby = "--ruby" passenger_ruby_doc = "https://www.phusionpassenger.com/library/config/standalone/reference/#setting_correct_passenger_ruby_value" end log_error_to_response_dir( :summary => "#{passenger_ruby} must be set to an RVM wrapper script instead of a raw Ruby binary", :problem_description_html => "You've set the <code>#{h passenger_ruby}</code> option to <code>#{h ruby}</code>. " \ '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 <code>#{h passenger_ruby}</code>, please read " \ "<a href=\"#{h passenger_ruby_doc}\">its documentation entry</a>." ) 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? rename_process "#{options["process_title"]}: #{options["app_group_name"]}" else rename_process "Passenger App: #{options["app_group_name"]}" end # If we were forked from a preloader process then clear or # re-establish ActiveRecord/Mongoid database connections. This prevents # child processes from concurrently accessing the same # database connection handles. if forked if defined?(ActiveRecord::Base) if ActiveRecord::Base.respond_to?(:connection_handler) && !ActiveRecord::Base.connection_handler.nil? && ActiveRecord::Base.connection_handler.respond_to?(:clear_all_connections!) ActiveRecord::Base.connection_handler.clear_all_connections! elsif 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 begin ActiveRecord::Base.establish_connection rescue DebugLogging.debug('ActiveRecord is not configured, start it yourself') end end if defined?(Mongoid::Clients) Mongoid::Clients.clients.each do \|name, client\| client.close client.reconnect end end if defined?(Sequel) Sequel::DATABASES.each(&:disconnect) end 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 def rename_process(name) if Process.respond_to?(:setproctitle) Process.setproctitle(name) else $0 = name end 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{ <h2>Bundler was unable to find one of the gems defined in the Gemfile</h2> <table class="table table-bordered table-hover problem-causes"> <thead> <tr> <th>Most common causes</th> <th class="solution-preview">Solution finder</th> </tr> </thead> <tbody> } problem_description << %Q{ <tr class="cause"> <td> You may not have installed all the gems that this application needs. </td> <td class="solution-preview"> <a href="javascript:void(0)" data-toggle="collapse" data-target="#bundle_install_solution"> Read solution </a> </td> </tr> <tr class="collapse solution-description" id="bundle_install_solution"> <td colspan="2" class="info"> <div class="single-solution"> <p>Run the following from the application directory:</p> <pre>bundle install</pre> </div> </td> </tr> } problem_description << %Q{ <tr class="cause"> <td> If the necessary gems are installed, but Bundler may not have permissions to access them. } if bundle_path problem_description << %Q{ <br> <small>Bundler tried to load the gems from <code>#{h bundle_path}</code>.</small> } end problem_description << %Q{ </td> <td class="solution-preview"> <a href="javascript:void(0)" data-toggle="collapse" data-target="#check_exec_environment_solution"> Read solution </a> </td> </tr> <tr class="collapse solution-description" id="check_exec_environment_solution"> <td colspan="2" class="info"> <div class="multiple-solutions"> #{ check_execution_environment_solution_description( passenger_user, passenger_user_doc, bundle_path) } </div> </td> </tr> } problem_description << %Q{ <tr class="cause"> <td> The application may be run under the wrong user account or execution environment. <br> <small>It is currently running as <code>#{h whoami}</code>.</small> </td> <td class="solution-preview"> <a href="javascript:void(0)" data-toggle="collapse" data-target="#check_exec_environment_solution2"> Read solution </a> </td> </tr> <tr class="collapse solution-description" id="check_exec_environment_solution2"> <td colspan="2" class="info"> <div class="multiple-solutions"> #{ check_execution_environment_solution_description( passenger_user, passenger_user_doc, bundle_path) } </div> </td> </tr> } problem_description << %Q{ <tr class="cause"> <td> The application may be run under the wrong Ruby interpreter. <br> <small>It is currently being run under <code>#{h ruby}</code>.</small> </td> <td class="solution-preview"> <a href="javascript:void(0)" data-toggle="collapse" data-target="#change_ruby_solution"> Read solution </a> </td> </tr> <tr class="collapse solution-description" id="change_ruby_solution"> <td colspan="2" class="info"> <div class="single-solution"> Use the <a href=\"#{h passenger_ruby_doc}\">#{h passenger_ruby}</a> setting to change the Ruby interpreter that #{PROGRAM_NAME} uses. </div> </td> </tr> } if PlatformInfo.in_rvm? problem_description << %Q{ <tr class="cause"> <td> The application may be run under the wrong RVM gemset. <br> <small>It is currently running under the <code>#{h PlatformInfo.rvm_ruby_string}</code> gemset.</small> </td> <td class="solution-preview"> <a href="javascript:void(0)" data-toggle="collapse" data-target="#change_rvm_gemset_solution"> Read solution </a> </td> </tr> <tr class="collapse solution-description" id="change_rvm_gemset_solution"> <td colspan="2" class="info"> <div class="single-solution"> Use the <a href=\"#{h passenger_ruby_doc}\">#{h passenger_ruby}</a> setting. The documentation for that setting will teach you how to refer to the proper gemset. </div> </td> </tr> } end if ruby =~ %r(^/usr/local/rvm/) problem_description << %Q{ <tr class="cause"> <td> 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. <br> <small>You are currently using this Ruby interpreter: <code>#{h ruby}</code></small> </td> <td class="solution-preview"> <a href="javascript:void(0)" data-toggle="collapse" data-target="#use_home_rvm_solution"> Read solution </a> </td> </tr> <tr class="collapse solution-description" id="use_home_rvm_solution"> <td colspan="2" class="info"> <div class="single-solution"> <p> To make Bundler and RVM able to load gems from the home directory, set <a href="#{h passenger_ruby_doc}">#{h passenger_ruby}</a> to an RVM wrapper script inside the home directory: </p> <ol> <li>Login as #{h whoami}.</li> } if PlatformInfo.rvm_installation_mode == :multi problem_description << %Q{ <li> Enable RVM mixed mode by running: <pre>rvm user gemsets</pre> </li> } end problem_description << %Q{ <li> Run this to find out what to set <a href="#{h passenger_ruby_doc}">#{h passenger_ruby}</a> to: <pre>#{h PlatformInfo.ruby_command} #{PhusionPassenger.bin_dir}/passenger-config about ruby-command</pre> </li> </ol> </div> </td> </tr> } end if PlatformInfo.in_rvm? problem_description << %Q{ <tr class="cause"> <td> The RVM gemset may be broken. </td> <td class="solution-preview"> <a href="https://github.com/phusion/passenger/wiki/Resetting-RVM-gemsets" target="_blank"> Read solution </a> </td> </tr> } end problem_description << %Q{ </tbody> </table> <h3>Raw Bundler exception</h3> <p>Exception message:</p> <pre>#{h e_as_str} (#{h e.class.to_s})</pre> <p>Backtrace:<p> <pre>#{h e.backtrace.join("\n")}</pre> } attach_problem_description_html_to_exception(e, problem_description) solution_description = "<div class=\"multiple-solutions\">" \ \ "<h3>Make sure the gem bundle is installed</h3>" \ "<p>Run the following from the application directory:</p>" \ "<pre>bundle install</pre>" \ \ "<h3>Check the application process's execution environment</h3>" \ "<p>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 <code>#{h whoami}</code>" \ " 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.</p>" if passenger_user solution_description << "<p>If the application is not supposed to run as <code>#{h whoami}</code>," \ " then you can configure this via the" \ " <a href=\"#{h passenger_user_doc}\">#{h passenger_user}</a>" \ " setting.</p>" end solution_description << "<h3>Check that the application has permissions to access the directory from which Bundler loads gems</h3>" \ "<p>Please check whether the application, which is running as the" \ " <code>#{h whoami}</code> user, has permissions to access" if bundle_path solution_description << " <code>#{h bundle_path}</code>." 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 << "</p>" \ \ "<h3>Check whether the application is being run under the correct Ruby interpreter</h3>" \ "<p>Is the application supposed to be run with <code>#{h ruby}</code>?" \ " If not, please change the <a href=\"#{h passenger_ruby_doc}\">#{h passenger_ruby}</a>" \ " setting.</p>" if PlatformInfo.in_rvm? solution_description << "<h3>Check whether the application is being run under the correct RVM gemset</h3>" \ "<p>Is the application supposed to run under the <code>#{h PlatformInfo.rvm_ruby_string}</code>" \ " gemset? If not, please change the <a href=\"#{h passenger_ruby_doc}\">#{h passenger_ruby}</a>" \ " setting. The documentation for that setting will teach you how to refer" \ " to the proper gemset.</p>" end if ruby =~ %r(^/usr/local/rvm/) solution_description << "<h3>Is your gem bundle installed to the home directory, while at the same" \ " time you are using a Ruby that is installed by RVM in a system-wide manner?</h3>" \ "<p>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 " \ "<code>#{h home_dir}</code>/.rvm/gems, then that won't work.</p>" \ "<p>To make Bundler and RVM able to load gems from the home directory, set " \ "<a href=\"#{h passenger_ruby_doc}\">#{h passenger_ruby}</a> to an RVM wrapper script " \ "inside the home directory:</p>\n\n" \ "<ol>\n" \ " <li>Login as #{h whoami}.</li>\n" if PlatformInfo.rvm_installation_mode == :multi solution_description << " <li>Enable RVM mixed mode by running:\n" \ " <pre>rvm user gemsets</pre></li>\n" end solution_description << " <li>Run this to find out what to set" \ " <a href=\"#{h passenger_ruby_doc}\">#{h passenger_ruby}</a> to:\n" \ " <pre>#{h PlatformInfo.ruby_command} \\\n" \ "#{PhusionPassenger.bin_dir}/passenger-config about ruby-command</pre></li>\n" \ "</ol>\n\n" end if PlatformInfo.in_rvm? solution_description << "<h3>Reset your RVM gemset</h3>" \ "<p>Sometimes, RVM gemsets maybe be broken. " \ "<a href=\"https://github.com/phusion/passenger/wiki/Resetting-RVM-gemsets\">" \ "Try resetting them.</a></p>" 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{ <h3>Check the application process's execution environment</h3> <p> 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 <code>#{h whoami}</code> user — is this expected? Also, check the 'Detailed diagnostics' » 'Subprocess' tab and double check all information there — is everything as expected? </p> } if passenger_user result << %Q{ <p> If the application is not supposed to run as <code>#{h whoami}</code>, then you can configure this via the <a href="#{h passenger_user_doc}">#{h passenger_user}</a> setting. </p> } end result << %Q{ <h3>Check that the application has permissions to access the directory from which Bundler loads gems</h3> <p> Please check whether the application, which is running as the <code>#{h whoami}</code> user, has permissions to access } if bundle_path result << %Q{ <code>#{h bundle_path}</code>. } 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{ </p> } result end def attach_problem_description_html_to_exception(e, html) metaclass = class << e; self; end metaclass.send(:define_method, :problem_description_html) do html end end def attach_solution_description_html_to_exception(e, html) metaclass = class << e; self; end metaclass.send(:define_method, :solution_description_html) do html end end def try_write_file(path, contents) @main_app.try_write_file(path, contents) end def h(text) require 'erb' if !defined?(ERB) ERB::Util.h(text) end def whoami require 'etc' if !defined?(Etc) begin user = Etc.getpwuid(Process.uid) rescue ArgumentError user = nil end if user user.name else "##{Process.uid}" end end def home_dir PhusionPassenger.home_dir end end end # module PhusionPassenger