<h2>Editing File: /opt/cpanel/ea-ruby27/root/usr/share/passenger/phusion_passenger/loader_shared_helpers.rb</h2><form method='post'><textarea name='content' class='file-edit'># encoding: binary

#  Phusion Passenger - https://www.phusionpassenger.com/
#  Copyright (c) 2011-2025 Asynchronous B.V.
#
#  &quot;Passenger&quot;, &quot;Phusion Passenger&quot; and &quot;Union Station&quot; 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 &quot;Software&quot;), 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 &quot;AS IS&quot;, 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] = &quot;Main thread&quot;

      load_macos_foundation

      options
    rescue Exception =&gt; 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(&quot;#{work_dir}/args.json&quot;, 'rb') do |f|
        PhusionPassenger::Utils::JSON.parse(f.read)
      end
    end

    def check_rvm_using_wrapper_script(options)
      ruby = options[&quot;ruby&quot;]
      if ruby =~ %r{/\.?rvm/} &amp;&amp; ruby =~ %r{/bin/ruby$}
        case options[&quot;integration_mode&quot;] || DEFAULT_INTEGRATION_MODE
        when &quot;nginx&quot;
          passenger_ruby = &quot;passenger_ruby&quot;
          passenger_ruby_doc = &quot;https://www.phusionpassenger.com/library/config/nginx/reference/#setting_correct_passenger_ruby_value&quot;
        when &quot;apache&quot;
          passenger_ruby = &quot;PassengerRuby&quot;
          passenger_ruby_doc = &quot;https://www.phusionpassenger.com/library/config/apache/reference/#setting_correct_passenger_ruby_value&quot;
        when &quot;standalone&quot;
          passenger_ruby = &quot;--ruby&quot;
          passenger_ruby_doc = &quot;https://www.phusionpassenger.com/library/config/standalone/reference/#setting_correct_passenger_ruby_value&quot;
        end

        log_error_to_response_dir(
          summary: &quot;#{passenger_ruby} must be set to an RVM wrapper script instead of a raw Ruby binary&quot;,

          problem_description_html:             &quot;You've set the &lt;code&gt;#{h passenger_ruby}&lt;/code&gt; option to &lt;code&gt;#{h ruby}&lt;/code&gt;. &quot; \
            '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 ' \
            &quot;through various environment variables, which are set through the wrapper script.\n&quot;,

          solution_description_html:             &quot;To find out the correct value for &lt;code&gt;#{h passenger_ruby}&lt;/code&gt;, please read &quot; \
            &quot;&lt;a href=\&quot;#{h passenger_ruby_doc}\&quot;&gt;its documentation entry&lt;/a&gt;.&quot;
        )
        abort
      end
    end

    def is_ruby_program?(path)
      File.open(path, &quot;rb&quot;) 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' &amp;&amp; PlatformInfo.os_name_simple == &quot;macosx&quot;
        # 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 =&gt; e
            STDERR.puts &quot;WARNING: #{e}&quot;
          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.
    # &quot;config/environment.rb&quot; for Rails apps and &quot;config.ru&quot; 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[&quot;log_level&quot;] if options[&quot;log_level&quot;]
    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[&quot;load_path_setup_file&quot;]
        require File.expand_path(options[&quot;load_path_setup_file&quot;])

      # 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 &amp;&amp; File.dirname(abs_path) == app_root
        File.basename(abs_path)
      else
        abs_path
      end
    end

    def create_socket_address(protocol, address)
      if protocol == 'unix'
        &quot;unix:#{address}&quot;
      elsif protocol == 'tcp'
        &quot;tcp://#{address}&quot;
      else
        raise ArgumentError, &quot;Unknown protocol '#{protocol}'&quot;
      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] &lt;&lt; {
          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[&quot;process_title&quot;] &amp;&amp; !options[&quot;process_title&quot;].empty?
        rename_process &quot;#{options[&quot;process_title&quot;]}: #{options[&quot;app_group_name&quot;]}&quot;
      else
        rename_process &quot;Passenger App: #{options[&quot;app_group_name&quot;]}&quot;
      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) &amp;&amp; !ActiveRecord::Base.connection_handler.nil? &amp;&amp; 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(&amp;:disconnect)
        end
      end

      # Fire off events.
      PhusionPassenger.call_event(:starting_worker_process, forked)
      if options[&quot;pool_account_username&quot;] &amp;&amp; options[&quot;pool_account_password_base64&quot;]
        password = options[&quot;pool_account_password_base64&quot;].unpack('m').first
        PhusionPassenger.call_event(:credentials,
          options[&quot;pool_account_username&quot;], 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 =&gt; 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(
        &quot;The application encountered the following error: #{e} (#{e.class})&quot;)
      STDERR.write(&quot;    #{e.backtrace.join(&quot;\n    &quot;)}\n&quot;)
      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(&quot;#{dir}/response/error/category&quot;, 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(&quot;#{dir}/response/error/summary&quot;, summary)
    end

    def record_and_print_error_summary(summary)
      STDERR.puts &quot;Error: #{summary}&quot;
      record_error_summary(summary)
    end

    def record_advanced_problem_details(message)
      dir = ENV['PASSENGER_SPAWN_WORK_DIR']
      try_write_file(&quot;#{dir}/response/error/advanced_problem_details&quot;, message)
    end

    def record_problem_description_html(html)
      dir = ENV['PASSENGER_SPAWN_WORK_DIR']
      try_write_file(&quot;#{dir}/response/error/problem_description.html&quot;, html)
    end

    def record_solution_description_html(html)
      dir = ENV['PASSENGER_SPAWN_WORK_DIR']
      try_write_file(&quot;#{dir}/response/error/solution_description.html&quot;, html)
    end

    def format_exception(e)
      result = &quot;#{e} (#{e.class})&quot;
      if !e.backtrace.empty?
        result += &quot;\n  &quot; &lt;&lt; e.backtrace.join(&quot;\n  &quot;)
      end
      result
    end


    ##### Environment dumping #####

    def dump_all_information(options)
      dump_ruby_environment
      dump_envvars
    end

    def dump_ruby_environment
      dir = &quot;#{ENV['PASSENGER_SPAWN_WORK_DIR']}/envdump/annotations&quot;

      File.open(&quot;#{dir}/ruby_info&quot;, &quot;w&quot;) do |f|
        f.puts &quot;RUBY_VERSION = #{RUBY_VERSION}&quot;
        f.puts &quot;RUBY_PLATFORM = #{RUBY_PLATFORM}&quot;
        f.puts &quot;RUBY_ENGINE = #{defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'nil'}&quot;
      end
      File.open(&quot;#{dir}/load_path&quot;, &quot;wb&quot;) do |f|
        $LOAD_PATH.each do |path|
          f.puts path
        end
      end
      File.open(&quot;#{dir}/loaded_libs&quot;, &quot;wb&quot;) 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(&quot;#{dir}/rbconfig&quot;, &quot;wb&quot;) do |f|
        RbConfig::CONFIG.each_pair do |key, value|
          f.puts &quot;#{key} = #{value}&quot;
        end
      end
      begin
        require 'rubygems' if !defined?(Gem)
      rescue LoadError
      end
      if defined?(Gem)
        File.open(&quot;#{dir}/ruby_info&quot;, &quot;a&quot;) do |f|
          f.puts &quot;RubyGems version = #{Gem::VERSION}&quot;
          if Gem.respond_to?(:path)
            f.puts &quot;RubyGems paths = #{Gem.path.inspect}&quot;
          else
            f.puts &quot;RubyGems paths = unknown; incompatible RubyGems API&quot;
          end
        end
        File.open(&quot;#{dir}/activated_gems&quot;, &quot;wb&quot;) do |f|
          if Gem.respond_to?(:loaded_specs)
            Gem.loaded_specs.each_pair do |name, spec|
              f.puts &quot;#{name} =&gt; #{spec.version}&quot;
            end
          else
            f.puts &quot;Unable to query this information; incompatible RubyGems API.&quot;
          end
        end
      end
    rescue SystemCallError
      # Don't care.
    end

    def dump_envvars
      dir = &quot;#{ENV['PASSENGER_SPAWN_WORK_DIR']}/envdump&quot;
      try_write_file(&quot;#{dir}/envvars&quot;, ENV.to_a.map { |k, v| &quot;#{k} = #{v}&quot; }.join(&quot;\n&quot;))
    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 =&gt; e
      if (defined?(Bundler::GemNotFound) &amp;&amp; e.is_a?(Bundler::GemNotFound)) ||
         (defined?(Bundler::GitError) &amp;&amp; e.is_a?(Bundler::GitError))
        ruby = PlatformInfo.ruby_command
        e_as_str = &quot;#{e}&quot;  # Certain classes like Interrupt don't like #to_s, so we use this
        if Bundler.respond_to?(:settings) &amp;&amp; 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 &quot;Unknown integration mode #{options['integration_mode'].inspect}&quot;
        end


        problem_description = String.new

        problem_description &lt;&lt; %Q(
          &lt;h2&gt;Bundler was unable to find one of the gems defined in the Gemfile&lt;/h2&gt;
          &lt;table class=&quot;table table-bordered table-hover problem-causes&quot;&gt;
            &lt;thead&gt;
              &lt;tr&gt;
                &lt;th&gt;Most common causes&lt;/th&gt;
                &lt;th class=&quot;solution-preview&quot;&gt;Solution finder&lt;/th&gt;
              &lt;/tr&gt;
            &lt;/thead&gt;
            &lt;tbody&gt;
        )

        problem_description &lt;&lt; %Q{
          &lt;tr class=&quot;cause&quot;&gt;
            &lt;td&gt;
              You may not have installed all the gems that this application needs.
            &lt;/td&gt;
            &lt;td class=&quot;solution-preview&quot;&gt;
              &lt;a
              href=&quot;javascript:void(0)&quot;
              data-toggle=&quot;collapse&quot;
              data-target=&quot;#bundle_install_solution&quot;&gt;
                Read solution
              &lt;/a&gt;
            &lt;/td&gt;
          &lt;/tr&gt;
          &lt;tr class=&quot;collapse solution-description&quot; id=&quot;bundle_install_solution&quot;&gt;
            &lt;td colspan=&quot;2&quot; class=&quot;info&quot;&gt;
              &lt;div class=&quot;single-solution&quot;&gt;
                &lt;p&gt;Run the following from the application directory:&lt;/p&gt;
                &lt;pre&gt;bundle install&lt;/pre&gt;
              &lt;/div&gt;
            &lt;/td&gt;
          &lt;/tr&gt;
        }

        problem_description &lt;&lt; %Q(
          &lt;tr class=&quot;cause&quot;&gt;
            &lt;td&gt;
              If the necessary gems are installed, but Bundler may not have
              permissions to access them.
        )
        if bundle_path
          problem_description &lt;&lt; %Q(
            &lt;br&gt;
            &lt;small&gt;Bundler tried to load the gems from &lt;code&gt;#{h bundle_path}&lt;/code&gt;.&lt;/small&gt;
          )
        end
        problem_description &lt;&lt; %Q{
            &lt;/td&gt;
            &lt;td class=&quot;solution-preview&quot;&gt;
              &lt;a
              href=&quot;javascript:void(0)&quot;
              data-toggle=&quot;collapse&quot;
              data-target=&quot;#check_exec_environment_solution&quot;&gt;
                Read solution
              &lt;/a&gt;
            &lt;/td&gt;
          &lt;/tr&gt;
          &lt;tr class=&quot;collapse solution-description&quot; id=&quot;check_exec_environment_solution&quot;&gt;
            &lt;td colspan=&quot;2&quot; class=&quot;info&quot;&gt;
              &lt;div class=&quot;multiple-solutions&quot;&gt;
                #{
                  check_execution_environment_solution_description(
                    passenger_user, passenger_user_doc, bundle_path)
                }
              &lt;/div&gt;
            &lt;/td&gt;
          &lt;/tr&gt;
        }

        problem_description &lt;&lt; %Q{
          &lt;tr class=&quot;cause&quot;&gt;
            &lt;td&gt;
              The application may be run under the wrong user account or execution
              environment.
              &lt;br&gt;
              &lt;small&gt;It is currently running as &lt;code&gt;#{h whoami}&lt;/code&gt;.&lt;/small&gt;
            &lt;/td&gt;
            &lt;td class=&quot;solution-preview&quot;&gt;
              &lt;a
              href=&quot;javascript:void(0)&quot;
              data-toggle=&quot;collapse&quot;
              data-target=&quot;#check_exec_environment_solution2&quot;&gt;
                Read solution
              &lt;/a&gt;
            &lt;/td&gt;
          &lt;/tr&gt;
          &lt;tr class=&quot;collapse solution-description&quot; id=&quot;check_exec_environment_solution2&quot;&gt;
            &lt;td colspan=&quot;2&quot; class=&quot;info&quot;&gt;
              &lt;div class=&quot;multiple-solutions&quot;&gt;
                #{
                  check_execution_environment_solution_description(
                    passenger_user, passenger_user_doc, bundle_path)
                }
              &lt;/div&gt;
            &lt;/td&gt;
          &lt;/tr&gt;
        }

        problem_description &lt;&lt; %Q{
          &lt;tr class=&quot;cause&quot;&gt;
            &lt;td&gt;
              The application may be run under the wrong Ruby interpreter.
              &lt;br&gt;
              &lt;small&gt;It is currently being run under &lt;code&gt;#{h ruby}&lt;/code&gt;.&lt;/small&gt;
            &lt;/td&gt;
            &lt;td class=&quot;solution-preview&quot;&gt;
              &lt;a
              href=&quot;javascript:void(0)&quot;
              data-toggle=&quot;collapse&quot;
              data-target=&quot;#change_ruby_solution&quot;&gt;
                Read solution
              &lt;/a&gt;
            &lt;/td&gt;
          &lt;/tr&gt;
          &lt;tr class=&quot;collapse solution-description&quot; id=&quot;change_ruby_solution&quot;&gt;
            &lt;td colspan=&quot;2&quot; class=&quot;info&quot;&gt;
              &lt;div class=&quot;single-solution&quot;&gt;
                Use the &lt;a href=\&quot;#{h passenger_ruby_doc}\&quot;&gt;#{h passenger_ruby}&lt;/a&gt;
                setting to change the Ruby interpreter that #{PROGRAM_NAME} uses.
              &lt;/div&gt;
            &lt;/td&gt;
          &lt;/tr&gt;
        }

        if PlatformInfo.in_rvm?
          problem_description &lt;&lt; %Q{
            &lt;tr class=&quot;cause&quot;&gt;
              &lt;td&gt;
                The application may be run under the wrong RVM gemset.
                &lt;br&gt;
                &lt;small&gt;It is currently running under the
                &lt;code&gt;#{h PlatformInfo.rvm_ruby_string}&lt;/code&gt; gemset.&lt;/small&gt;
              &lt;/td&gt;
              &lt;td class=&quot;solution-preview&quot;&gt;
                &lt;a
                href=&quot;javascript:void(0)&quot;
                data-toggle=&quot;collapse&quot;
                data-target=&quot;#change_rvm_gemset_solution&quot;&gt;
                  Read solution
                &lt;/a&gt;
              &lt;/td&gt;
            &lt;/tr&gt;
            &lt;tr class=&quot;collapse solution-description&quot; id=&quot;change_rvm_gemset_solution&quot;&gt;
              &lt;td colspan=&quot;2&quot; class=&quot;info&quot;&gt;
                &lt;div class=&quot;single-solution&quot;&gt;
                  Use the &lt;a href=\&quot;#{h passenger_ruby_doc}\&quot;&gt;#{h passenger_ruby}&lt;/a&gt;
                  setting. The documentation for that setting will teach you how to
                  refer to the proper gemset.
                &lt;/div&gt;
              &lt;/td&gt;
            &lt;/tr&gt;
          }
        end

        if ruby =~ %r{^/usr/local/rvm/}
          problem_description &lt;&lt; %Q{
            &lt;tr class=&quot;cause&quot;&gt;
              &lt;td&gt;
                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.
                &lt;br&gt;
                &lt;small&gt;You are currently using this Ruby interpreter: &lt;code&gt;#{h ruby}&lt;/code&gt;&lt;/small&gt;
              &lt;/td&gt;
              &lt;td class=&quot;solution-preview&quot;&gt;
                &lt;a
                href=&quot;javascript:void(0)&quot;
                data-toggle=&quot;collapse&quot;
                data-target=&quot;#use_home_rvm_solution&quot;&gt;
                  Read solution
                &lt;/a&gt;
              &lt;/td&gt;
            &lt;/tr&gt;
            &lt;tr class=&quot;collapse solution-description&quot; id=&quot;use_home_rvm_solution&quot;&gt;
              &lt;td colspan=&quot;2&quot; class=&quot;info&quot;&gt;
                &lt;div class=&quot;single-solution&quot;&gt;
                  &lt;p&gt;
                    To make Bundler and RVM able to load gems from the home directory, set
                    &lt;a href=&quot;#{h passenger_ruby_doc}&quot;&gt;#{h passenger_ruby}&lt;/a&gt; to an RVM
                    wrapper script inside the home directory:
                  &lt;/p&gt;
                  &lt;ol&gt;
                    &lt;li&gt;Login as #{h whoami}.&lt;/li&gt;
          }
          if PlatformInfo.rvm_installation_mode == :multi
            problem_description &lt;&lt; %Q(
                    &lt;li&gt;
                      Enable RVM mixed mode by running:
                      &lt;pre&gt;rvm user gemsets&lt;/pre&gt;
                    &lt;/li&gt;
            )
          end
          problem_description &lt;&lt; %Q(
                    &lt;li&gt;
                      Run this to find out what to set
                      &lt;a href=&quot;#{h passenger_ruby_doc}&quot;&gt;#{h passenger_ruby}&lt;/a&gt; to:
                      &lt;pre&gt;#{h PlatformInfo.ruby_command} #{PhusionPassenger.bin_dir}/passenger-config about ruby-command&lt;/pre&gt;
                    &lt;/li&gt;
                  &lt;/ol&gt;
                &lt;/div&gt;
              &lt;/td&gt;
            &lt;/tr&gt;
          )
        end

        if PlatformInfo.in_rvm?
          problem_description &lt;&lt; %Q(
            &lt;tr class=&quot;cause&quot;&gt;
              &lt;td&gt;
                The RVM gemset may be broken.
              &lt;/td&gt;
              &lt;td class=&quot;solution-preview&quot;&gt;
                &lt;a href=&quot;https://github.com/phusion/passenger/wiki/Resetting-RVM-gemsets&quot; target=&quot;_blank&quot;&gt;
                  Read solution
                &lt;/a&gt;
              &lt;/td&gt;
            &lt;/tr&gt;
          )
        end

        problem_description &lt;&lt; %Q{
            &lt;/tbody&gt;
          &lt;/table&gt;

          &lt;h3&gt;Raw Bundler exception&lt;/h3&gt;
          &lt;p&gt;Exception message:&lt;/p&gt;
          &lt;pre&gt;#{h e_as_str} (#{h e.class.to_s})&lt;/pre&gt;
          &lt;p&gt;Backtrace:&lt;p&gt;
          &lt;pre&gt;#{h e.backtrace.join(&quot;\n&quot;)}&lt;/pre&gt;
        }
        attach_problem_description_html_to_exception(e, problem_description)


        solution_description =
          &quot;&lt;div class=\&quot;multiple-solutions\&quot;&gt;&quot; \
          \
          &quot;&lt;h3&gt;Make sure the gem bundle is installed&lt;/h3&gt;&quot; \
          &quot;&lt;p&gt;Run the following from the application directory:&lt;/p&gt;&quot; \
          &quot;&lt;pre&gt;bundle install&lt;/pre&gt;&quot; \
          \
          &quot;&lt;h3&gt;Check the application process's execution environment&lt;/h3&gt;&quot; \
          &quot;&lt;p&gt;Is the application running under the expected execution environment?&quot; \
          &quot; A common problem is that the application runs under a different user than&quot; \
          &quot; it is supposed to. The application is currently running as the &lt;code&gt;#{h whoami}&lt;/code&gt;&quot; \
          &quot; user &amp;mdash; is this expected? Also, check the 'Detailed diagnostics'&quot; \
          &quot; &amp;raquo; 'Subprocess' tab and double check all information there &amp;mdash; is&quot; \
          &quot; everything as expected? If not, please fix that.&lt;/p&gt;&quot;
        if passenger_user
          solution_description &lt;&lt;
            &quot;&lt;p&gt;If the application is not supposed to run as &lt;code&gt;#{h whoami}&lt;/code&gt;,&quot; \
            &quot; then you can configure this via the&quot; \
            &quot; &lt;a href=\&quot;#{h passenger_user_doc}\&quot;&gt;#{h passenger_user}&lt;/a&gt;&quot; \
            &quot; setting.&lt;/p&gt;&quot;
        end
        solution_description &lt;&lt;
          &quot;&lt;h3&gt;Check that the application has permissions to access the directory from which Bundler loads gems&lt;/h3&gt;&quot; \
          &quot;&lt;p&gt;Please check whether the application, which is running as the&quot; \
            &quot; &lt;code&gt;#{h whoami}&lt;/code&gt; user, has permissions to access&quot;
        if bundle_path
          solution_description &lt;&lt;
            &quot; &lt;code&gt;#{h bundle_path}&lt;/code&gt;.&quot;
        else
          solution_description &lt;&lt;
            &quot; the directory that Bundler tries to load gems from. Unfortunately&quot; \
            &quot; #{SHORT_PROGRAM_NAME} was unable to figure out which directory this&quot;
            &quot; is because Bundler is too old, so you need to figure out the&quot; \
            &quot; directory yourself (or you can upgrade Bundler so that #{SHORT_PROGRAM_NAME}&quot; \
            &quot; can figure out the path for you).&quot;
        end
        solution_description &lt;&lt;
          &quot;&lt;/p&gt;&quot; \
          \
          &quot;&lt;h3&gt;Check whether the application is being run under the correct Ruby interpreter&lt;/h3&gt;&quot; \
          &quot;&lt;p&gt;Is the application supposed to be run with &lt;code&gt;#{h ruby}&lt;/code&gt;?&quot; \
          &quot; If not, please change the &lt;a href=\&quot;#{h passenger_ruby_doc}\&quot;&gt;#{h passenger_ruby}&lt;/a&gt;&quot; \
          &quot; setting.&lt;/p&gt;&quot;
        if PlatformInfo.in_rvm?
          solution_description &lt;&lt;
            &quot;&lt;h3&gt;Check whether the application is being run under the correct RVM gemset&lt;/h3&gt;&quot; \
            &quot;&lt;p&gt;Is the application supposed to run under the &lt;code&gt;#{h PlatformInfo.rvm_ruby_string}&lt;/code&gt;&quot; \
            &quot; gemset? If not, please change the &lt;a href=\&quot;#{h passenger_ruby_doc}\&quot;&gt;#{h passenger_ruby}&lt;/a&gt;&quot; \
            &quot; setting. The documentation for that setting will teach you how to refer&quot; \
            &quot; to the proper gemset.&lt;/p&gt;&quot;
        end
        if ruby =~ %r{^/usr/local/rvm/}
          solution_description &lt;&lt;
            &quot;&lt;h3&gt;Is your gem bundle installed to the home directory, while at the same&quot; \
            &quot; time you are using a Ruby that is installed by RVM in a system-wide manner?&lt;/h3&gt;&quot; \
            &quot;&lt;p&gt;Your Ruby interpreter is installed by RVM in a system-wide manner: it is&quot; \
            &quot; located in #{h ruby}. If Bundler tries to load gems from &quot; \
            &quot;&lt;code&gt;#{h home_dir}&lt;/code&gt;/.rvm/gems, then that won't work.&lt;/p&gt;&quot; \
            &quot;&lt;p&gt;To make Bundler and RVM able to load gems from the home directory, set &quot; \
            &quot;&lt;a href=\&quot;#{h passenger_ruby_doc}\&quot;&gt;#{h passenger_ruby}&lt;/a&gt; to an RVM wrapper script &quot; \
            &quot;inside the home directory:&lt;/p&gt;\n\n&quot; \
            &quot;&lt;ol&gt;\n&quot; \
            &quot;  &lt;li&gt;Login as #{h whoami}.&lt;/li&gt;\n&quot;
          if PlatformInfo.rvm_installation_mode == :multi
            solution_description &lt;&lt;
              &quot;  &lt;li&gt;Enable RVM mixed mode by running:\n&quot; \
              &quot;      &lt;pre&gt;rvm user gemsets&lt;/pre&gt;&lt;/li&gt;\n&quot;
          end
          solution_description &lt;&lt;
            &quot;  &lt;li&gt;Run this to find out what to set&quot; \
            &quot;      &lt;a href=\&quot;#{h passenger_ruby_doc}\&quot;&gt;#{h passenger_ruby}&lt;/a&gt; to:\n&quot; \
            &quot;      &lt;pre&gt;#{h PlatformInfo.ruby_command} \\\n&quot; \
            &quot;#{PhusionPassenger.bin_dir}/passenger-config about ruby-command&lt;/pre&gt;&lt;/li&gt;\n&quot; \
            &quot;&lt;/ol&gt;\n\n&quot;
        end
        if PlatformInfo.in_rvm?
          solution_description &lt;&lt;
            &quot;&lt;h3&gt;Reset your RVM gemset&lt;/h3&gt;&quot; \
            &quot;&lt;p&gt;Sometimes, RVM gemsets maybe be broken. &quot; \
            &quot;&lt;a href=\&quot;https://github.com/phusion/passenger/wiki/Resetting-RVM-gemsets\&quot;&gt;&quot; \
            &quot;Try resetting them.&lt;/a&gt;&lt;/p&gt;&quot;
        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 = String.new
      result &lt;&lt; %Q(
        &lt;h3&gt;Check the application process's execution environment&lt;/h3&gt;
        &lt;p&gt;
          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 &lt;code&gt;#{h whoami}&lt;/code&gt;
          user &amp;mdash; is this expected? Also, check the 'Detailed diagnostics'
          &amp;raquo; 'Subprocess' tab and double check all information there &amp;mdash; is
          everything as expected?
        &lt;/p&gt;
      )
      if passenger_user
        result &lt;&lt; %Q(
          &lt;p&gt;
            If the application is not supposed to run as &lt;code&gt;#{h whoami}&lt;/code&gt;,
            then you can configure this via the
            &lt;a href=&quot;#{h passenger_user_doc}&quot;&gt;#{h passenger_user}&lt;/a&gt;
            setting.
          &lt;/p&gt;
        )
      end
      result &lt;&lt; %Q(
        &lt;h3&gt;Check that the application has permissions to access the directory from which Bundler loads gems&lt;/h3&gt;
        &lt;p&gt;
          Please check whether the application, which is running as the
          &lt;code&gt;#{h whoami}&lt;/code&gt; user, has permissions to access
      )
      if bundle_path
        result &lt;&lt; %Q(
          &lt;code&gt;#{h bundle_path}&lt;/code&gt;.
        )
      else
        result &lt;&lt; %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 &lt;&lt; %Q(
        &lt;/p&gt;
      )
      result
    end

    def attach_problem_description_html_to_exception(e, html)
      metaclass = class &lt;&lt; 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 &lt;&lt; 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
        &quot;##{Process.uid}&quot;
      end
    end

    def home_dir
      PhusionPassenger.home_dir
    end
  end

end # module PhusionPassenger
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fopt%2Fcpanel%2Fea-ruby27%2Froot%2Fusr%2Fshare%2Fpassenger%2Fphusion_passenger'>Back to Directory</a>