Provides shared functions for loader and preloader apps.
To be called whenever the (pre)loader is about to abort with an error.
# File lib/phusion_passenger/loader_shared_helpers.rb, line 61 def about_to_abort(exception = nil) dump_all_information # https://code.google.com/p/phusion-passenger/issues/detail?id=1039 puts end
# File lib/phusion_passenger/loader_shared_helpers.rb, line 278 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 285 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
To be called after the request handler main loop is exited. This function will fire off necessary events perform necessary cleanup tasks.
# File lib/phusion_passenger/loader_shared_helpers.rb, line 341 def after_handling_requests PhusionPassenger.call_event(:stopping_worker_process) end
This method is to be called after loading the application code but before forking a worker process.
# File lib/phusion_passenger/loader_shared_helpers.rb, line 260 def after_loading_app_code(options) # Post-install framework extensions. Possibly preceded by a call to # PhusionPassenger.install_framework_extensions! if defined?(::Rails) && !defined?(::Rails::VERSION) require 'rails/version' 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.
# File lib/phusion_passenger/loader_shared_helpers.rb, line 299 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["analytics_logger"] options["analytics_logger"].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
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.
# File lib/phusion_passenger/loader_shared_helpers.rb, line 176 def before_loading_app_code_step1(startup_file, options) DebugLogging.log_level = options["log_level"] if options["log_level"] # Instantiate the analytics logger if requested. Can be nil. PhusionPassenger.require_passenger_lib 'analytics_logger' options["analytics_logger"] = AnalyticsLogger.new_from_options(options) end
# File lib/phusion_passenger/loader_shared_helpers.rb, line 254 def before_loading_app_code_step2(options) # Do nothing. end
# File lib/phusion_passenger/loader_shared_helpers.rb, line 44 def check_rvm_using_wrapper_script(options) ruby = options["ruby"] if ruby =~ %(/\.?rvm/) && ruby =~ %(/bin/ruby$) raise "You've set the `PassengerRuby` (Apache) or `passenger_ruby` (Nginx) 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 `PassengerRuby`/`passenger_ruby`, please read:\n\n" + " #{APACHE2_DOC_URL}#PassengerRuby\n\n" + " #{NGINX_DOC_URL}#PassengerRuby\n\n" + "Scroll to section 'RVM helper tool'.\n" + "\n-------------------------\n" end end
# File lib/phusion_passenger/loader_shared_helpers.rb, line 268 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 91 def dump_all_information dump_ruby_environment dump_envvars dump_system_memory_stats end
# File lib/phusion_passenger/loader_shared_helpers.rb, line 145 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 97 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}" 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 157 def dump_system_memory_stats if dir = ENV['PASSENGER_DEBUG_DIR'] File.open("#{dir}/sysmemory", "wb") do |f| f.write(`"#{PhusionPassenger.helper_scripts_dir}/system-memory-stats.py"`) end end rescue SystemCallError # Don't care. end
To be called by the (pre)loader as soon as possible.
# File lib/phusion_passenger/loader_shared_helpers.rb, line 35 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) 7 end
# File lib/phusion_passenger/loader_shared_helpers.rb, line 184 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 require 'rubygems' require '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 71 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
Generated with the Darkfish Rdoc Generator 2.