PhusionPassenger::LoaderSharedHelpers

# File lib/phusion_passenger/loader_shared_helpers.rb, line 72
def about_to_abort(options, exception = nil)
  dump_all_information(options)
  # https://code.google.com/p/phusion-passenger/issues/detail?id=1039
  puts
end

# File lib/phusion_passenger/loader_shared_helpers.rb, line 392
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

# File lib/phusion_passenger/loader_shared_helpers.rb, line 317
def advertise_readiness
  # https://code.google.com/p/phusion-passenger/issues/detail?id=1039
  puts

  puts "!> Ready"
end

# File lib/phusion_passenger/loader_shared_helpers.rb, line 324
def advertise_sockets(output, request_handler)
  request_handler.server_sockets.each_pair do |name, options|
    concurrency = PhusionPassenger.advertised_concurrency_level || options[:concurrency]
    output.puts "!> socket: #{name};#{options[:address]};#{options[:protocol]};#{concurrency}"
  end
end

# File lib/phusion_passenger/loader_shared_helpers.rb, line 380
def after_handling_requests
  PhusionPassenger.call_event(:stopping_worker_process)
end

# File lib/phusion_passenger/loader_shared_helpers.rb, line 303
def after_loading_app_code(options)
  # Do nothing.
end

# File lib/phusion_passenger/loader_shared_helpers.rb, line 338
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 forked && options["union_station_core"]
    options["union_station_core"].clear_connection
  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!
    elsif ActiveRecord::Base.respond_to?(:connected?) &&
          ActiveRecord::Base.connected?
      ActiveRecord::Base.establish_connection
    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

# File lib/phusion_passenger/loader_shared_helpers.rb, line 219
def before_loading_app_code_step1(startup_file, options)
  DebugLogging.log_level = options["log_level"] if options["log_level"]

  # Instantiate the Union Station core if requested. Can be nil.
  PhusionPassenger.require_passenger_lib 'union_station/core'
  options["union_station_core"] = UnionStation::Core.new_from_options(options)
  PhusionPassenger.union_station_key = options["union_station_key"]
end

# File lib/phusion_passenger/loader_shared_helpers.rb, line 297
def before_loading_app_code_step2(options)
  # Do nothing.
end

# File lib/phusion_passenger/loader_shared_helpers.rb, line 45
def check_rvm_using_wrapper_script(options)
  ruby = options["ruby"]
  if ruby =~ %(/\.?rvm/) && ruby =~ %(/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

    raise "You've set the `#{passenger_ruby}` option to '#{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" +
      "\n" +
      "To find out the correct value for `#{passenger_ruby}`, please read:\n\n" +
      "  #{passenger_ruby_doc}\n" +
      "\n-------------------------\n"
  end
end

# File lib/phusion_passenger/loader_shared_helpers.rb, line 307
def create_socket_address(protocol, address)
  if protocol == 'unix'
    return "unix:#{address}"
  elsif protocol == 'tcp'
    return "tcp://#{address}"
  else
    raise ArgumentError, "Unknown protocol '#{protocol}'"
  end
end

# File lib/phusion_passenger/loader_shared_helpers.rb, line 102
def dump_all_information(options)
  dump_ruby_environment
  dump_envvars
  dump_system_metrics(options)
end

# File lib/phusion_passenger/loader_shared_helpers.rb, line 161
def dump_envvars
  if dir = ENV['PASSENGER_DEBUG_DIR']
    File.open("#{dir}/envvars", "wb") do |f|
      ENV.each_pair do |key, value|
        f.puts "#{key} = #{value}"
      end
    end
  end
rescue SystemCallError
  # Don't care.
end

# File lib/phusion_passenger/loader_shared_helpers.rb, line 108
def dump_ruby_environment
  if dir = ENV['PASSENGER_DEBUG_DIR']
    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
  end
rescue SystemCallError
  # Don't care.
end

# File lib/phusion_passenger/loader_shared_helpers.rb, line 173
def dump_system_metrics(options)
  if dir = ENV['PASSENGER_DEBUG_DIR']
    # When invoked through Passenger Standalone, we want passenger-config
    # to use the PassengerAgent in the Passsenger Standalone buildout directory,
    # because the one in the source root may not exist.
    passenger_config = "#{PhusionPassenger.bin_dir}/passenger-config"
    if is_ruby_program?(passenger_config)
      ruby = options["ruby"]
    else
      ruby = nil
    end
    command = [
      "env",
      "PASSENGER_LOCATION_CONFIGURATION_FILE=#{PhusionPassenger.install_spec}",
      ruby,
      passenger_config,
      "system-metrics"
    ].compact
    contents = `#{Shellwords.join(command)}`
    if $? && $?.exitstatus == 0
      File.open("#{dir}/system_metrics", "wb") do |f|
        f.write(contents)
      end
    end
  end
rescue SystemCallError
  # Don't care.
end

# File lib/phusion_passenger/loader_shared_helpers.rb, line 36
def init(options)
  Thread.main[:name] = "Main thread"
  # 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)
  return sanitize_spawn_options(options)
end

# File lib/phusion_passenger/loader_shared_helpers.rb, line 202
def is_ruby_program?(path)
  File.open(path, "rb") do |f|
    f.readline =~ /ruby/
  end
rescue EOFError
  false
end

# File lib/phusion_passenger/loader_shared_helpers.rb, line 228
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 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 indicates whether (2) is true:
  elsif File.exist?('Gemfile')
    # 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

# File lib/phusion_passenger/loader_shared_helpers.rb, line 82
def sanitize_spawn_options(options)
  defaults = {
    "app_type"         => "rack",
    "environment"      => "production",
    "print_exceptions" => true
  }
  options = defaults.merge(options)
  options["app_group_name"]            = options["app_root"] if !options["app_group_name"]
  options["print_exceptions"]          = to_boolean(options["print_exceptions"])
  options["analytics"]                 = to_boolean(options["analytics"])
  options["show_version_in_header"]    = to_boolean(options["show_version_in_header"])
  options["log_level"]                 = options["log_level"].to_i if options["log_level"]
  # TODO: smart spawning is not supported when using ruby-debug. We should raise an error
  # in this case.
  options["debugger"]     = to_boolean(options["debugger"])
  options["spawn_method"] = "direct" if options["debugger"]

  return options
end

# File lib/phusion_passenger/loader_shared_helpers.rb, line 78
def to_boolean(value)
  return !(value.nil? || value == false || value == "false")
end