Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2026-03-21 15:53
📄 abstract_installer.rb # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2010-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. PhusionPassenger.require_passenger_lib 'constants' PhusionPassenger.require_passenger_lib 'console_text_template' PhusionPassenger.require_passenger_lib 'platform_info' PhusionPassenger.require_passenger_lib 'platform_info/operating_system' PhusionPassenger.require_passenger_lib 'utils/ansi_colors' PhusionPassenger.require_passenger_lib 'utils/download' require 'fileutils' require 'logger' require 'etc' # IMPORTANT: do not directly or indirectly require native_support; we can't compile # it yet until we have a compiler, and installers usually check whether a compiler # is installed. module PhusionPassenger # Abstract base class for text mode installers. Used by # passenger-install-apache2-module and passenger-install-nginx-module. # # Subclasses must at least implement the #run_steps method which handles # the installation itself. # # Usage: # # installer = ConcereteInstallerClass.new(options...) # installer.run class AbstractInstaller PASSENGER_WEBSITE = "https://www.phusionpassenger.com" PASSENGER_LIBRARY_URL = "https://www.phusionpassenger.com/library/" PHUSION_WEBSITE = "www.phusion.nl" # Create an AbstractInstaller. All options will be stored as instance # variables, for example: # # installer = AbstractInstaller.new(:foo => "bar") # installer.instance_variable_get(:"@foo") # => "bar" def initialize(options = {}) @stdout = STDOUT @stderr = STDERR @auto = !STDIN.tty? @colors = Utils::AnsiColors.new(options[:colorize] \|\| :auto) options.each_pair do \|key, value\| instance_variable_set(:"@#{key}", value) end end # Start the installation by calling the #install! method. def run before_install run_steps return true rescue Abort puts return false rescue SignalException, SystemExit raise rescue PlatformInfo::RuntimeError => e new_screen puts "<red>An error occurred</red>" puts puts e.message exit 1 rescue Exception => e show_support_options_for_installer_bug(e) exit 2 ensure after_install end protected class Abort < StandardError end class CommandError < Abort end def interactive? return !@auto end def non_interactive? return !interactive? end def before_install if STDOUT.respond_to?(:set_encoding) STDOUT.set_encoding("UTF-8") end STDOUT.write(@colors.default_terminal_color) STDOUT.flush end def after_install STDOUT.write(@colors.reset) STDOUT.flush end def install_doc_url "https://www.phusionpassenger.com/library/install/" end def troubleshooting_doc_url "https://www.phusionpassenger.com/library/admin/troubleshooting/" end def dependencies return [[], []] end def check_dependencies(show_new_screen = true) new_screen if show_new_screen puts "<banner>Checking for required software...</banner>" puts PhusionPassenger.require_passenger_lib 'platform_info/depcheck' specs, ids = dependencies runner = PlatformInfo::Depcheck::ConsoleRunner.new(@colors) specs.each do \|spec\| PlatformInfo::Depcheck.load(spec) end ids.each do \|id\| runner.add(id) end if runner.check_all return true else puts puts "<red>Some required software is not installed.</red>" puts "But don't worry, this installer will tell you how to install them.\n" puts "<b>Press Enter to continue, or Ctrl-C to abort.</b>" if PhusionPassenger.originally_packaged? wait else wait(10) end line puts puts "<banner>Installation instructions for required software</banner>" puts runner.missing_dependencies.each do \|dep\| puts " * To install <yellow>#{dep.name}</yellow>:" puts " #{dep.install_instructions}" puts end puts "If the aforementioned instructions didn't solve your problem, then please take" puts "a look at our documentation for troubleshooting tips:" puts puts " <yellow>#{install_doc_url}</yellow>" puts " <yellow>#{troubleshooting_doc_url}</yellow>" return false end end def check_whether_os_is_broken # No known broken OSes at the moment. end def check_gem_install_permission_problems return true if PhusionPassenger.custom_packaged? begin require 'rubygems' rescue LoadError return true end if Process.uid != 0 && PhusionPassenger.build_system_dir =~ /^#{Regexp.escape home_dir}\// && PhusionPassenger.build_system_dir =~ /^#{Regexp.escape Gem.dir}\// && File.stat(PhusionPassenger.build_system_dir).uid == 0 new_screen render_template 'installer_common/gem_install_permission_problems' return false else return true end end def check_directory_accessible_by_web_server return true if PhusionPassenger.custom_packaged? inaccessible_directories = [] list_parent_directories(PhusionPassenger.build_system_dir).each do \|path\| if !world_executable?(path) inaccessible_directories << path end end if !inaccessible_directories.empty? new_screen render_template 'installer_common/world_inaccessible_directories', :directories => inaccessible_directories wait end end def check_whether_system_has_enough_ram(required = 1024) begin meminfo = File.read("/proc/meminfo") if meminfo =~ /^MemTotal: (\d+) kB$/ ram_mb = $1.to_i / 1024 if meminfo =~ /^SwapTotal: (\d+) kB$/ swap_mb = $1.to_i / 1024 else swap_mb = 0 end end rescue Errno::ENOENT, Errno::EACCES # Don't do anything on systems without memory information. ram_mb = nil swap_mb = nil end if ram_mb && swap_mb && ram_mb + swap_mb < required new_screen render_template 'installer_common/low_amount_of_memory_warning', :required => required, :current => ram_mb + swap_mb, :ram => ram_mb, :swap => swap_mb, :install_doc_url => install_doc_url wait end end def show_support_options_for_installer_bug(e) # We do not use template rendering here. Since we've determined that there's # a bug, anything may be broken, so we use the safest codepath to ensure that # the user sees the proper messages. begin line @stderr.puts "*** EXCEPTION: #{e} (#{e.class})\n " + e.backtrace.join("\n ") new_screen puts '<red>Oops, something went wrong :-(</red>' puts puts "We're sorry, but it looks like this installer ran into an unexpected problem.\n" + "Please visit the following website for support. We'll do our best to help you.\n\n" + " <b>#{SUPPORT_URL}</b>\n\n" + "When submitting a support inquiry, please copy and paste the entire installer\n" + "output." rescue Exception => e2 # Raise original exception so that it doesn't get lost. raise e end end def use_stderr old_stdout = @stdout begin @stdout = @stderr yield ensure @stdout = old_stdout end end def print(text) @stdout.write(@colors.ansi_colorize(text)) @stdout.flush end def puts(text = nil) if text @stdout.puts(@colors.ansi_colorize(text.to_s)) else @stdout.puts end @stdout.flush end def puts_error(text) @stderr.puts(@colors.ansi_colorize("<red>#{text}</red>")) @stderr.flush end def render_template(name, options = {}) options.merge!(:colors => @colors) puts ConsoleTextTemplate.new({ :file => name }, options).result end def new_screen puts line puts end def line puts "--------------------------------------------" end def prompt(message, default_value = nil) done = false while !done print "#{message}: " if non_interactive? && default_value puts default_value return default_value end begin result = STDIN.readline rescue EOFError exit 2 end result.strip! if result.empty? if default_value result = default_value done = true else done = !block_given? \|\| yield(result) end else done = !block_given? \|\| yield(result) end end return result rescue Interrupt raise Abort end def prompt_confirmation(message) result = prompt("#{message} [y/n]") do \|value\| if value.downcase == 'y' \|\| value.downcase == 'n' true else puts_error "Invalid input '#{value}'; please enter either 'y' or 'n'." false end end return result.downcase == 'y' rescue Interrupt raise Abort end def prompt_confirmation_with_default(message, default) if default default_str = "[Y/n]" else default_str = "[y/N]" end result = prompt("#{message} #{default_str}") do \|value\| if value.downcase == 'y' \|\| value.downcase == 'n' true elsif value.empty? true else puts_error "Invalid input '#{value}'; please enter either 'y' or 'n'." false end end if result.empty? return default else return result.downcase == 'y' end rescue Interrupt raise Abort end def wait(timeout = nil) if interactive? if timeout require 'timeout' unless defined?(Timeout) begin Timeout.timeout(timeout) do STDIN.readline end rescue Timeout::Error # Do nothing. end else STDIN.readline end end rescue Interrupt raise Abort end def home_dir return PhusionPassenger.home_dir end def sh(args) puts "# #{args.join(' ')}" result = system(args) if result return true elsif $?.signaled? && $?.termsig == Signal.list["INT"] raise Interrupt else return false end end def sh!(args) if !sh(args) puts_error "*** Command failed: #{args.join(' ')}" raise CommandError end end def rake(args) PhusionPassenger.require_passenger_lib 'platform_info/ruby' if !PlatformInfo.rake_command puts_error 'Cannot find Rake.' raise Abort end sh("#{PlatformInfo.rake_command} #{args.join(' ')}") end def rake!(args) PhusionPassenger.require_passenger_lib 'platform_info/ruby' if !PlatformInfo.rake_command puts_error 'Cannot find Rake.' raise Abort end sh!("#{PlatformInfo.rake_command} #{args.join(' ')}") end def download(url, output, options = {}) options[:logger] \|\|= begin logger = Logger.new(STDOUT) logger.level = Logger::WARN logger.formatter = proc { \|severity, datetime, progname, msg\| "*** #{msg}\n" } logger end return PhusionPassenger::Utils::Download.download(url, output, options) end def list_parent_directories(dir) dirs = [] components = File.expand_path(dir).split(File::SEPARATOR) components.shift # Remove leading / components.size.times do \|i\| dirs << File::SEPARATOR + components[0 .. i].join(File::SEPARATOR) end return dirs.reverse end def world_executable?(dir) begin stat = File.stat(dir) rescue Errno::EACCESS return false end return stat.mode & 0000001 != 0 end end end # module PhusionPassenger	13.22 KB	2025-11-20 11:36
📁 admin_tools	-	2026-03-21 15:53
📄 admin_tools.rb # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2010-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 module AdminTools def self.tmpdir ["PASSENGER_INSTANCE_REGISTRY_DIR", "TMPDIR"].each do \|name\| if ENV.has_key?(name) && !ENV[name].empty? return ENV[name] end end return Dir['/tmp/systemd-private--{httpd,nginx}.service-/tmp'].first \|\| "/tmp" end def self.process_is_alive?(pid) begin Process.kill(0, pid) return true rescue Errno::ESRCH return false rescue SystemCallError => e return true end end end # module AdminTools end # module PhusionPassenger	1.84 KB	2025-11-20 11:36
📁 apache2	-	2026-03-21 15:53
📄 common_library.rb # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2012-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. # This file lists all the Phusion Passenger C++ support library files and # contains code for calculating how to compile and how to link them into # executables. It's used by the build system (build/.rb) and by # src/ruby_supportlib/phusion_passenger/config/nginx_engine_compiler.rb PhusionPassenger.require_passenger_lib 'platform_info/crypto' class CommonLibraryBuilder include Rake::DSL if defined?(Rake::DSL) attr_reader :all_components, :selected_components, :output_dir def initialize(&block) @all_components = {} @all_ordered_components = [] @selected_components = {} @namespace = "common" if defined?(COMMON_OUTPUT_DIR) @output_dir = COMMON_OUTPUT_DIR + "libpassenger_common" else @output_dir = "." end instance_eval(&block) if block end def initialize_copy(other) [:all_components, :all_ordered_components, :selected_components, :namespace, :output_dir].each do \|name\| var_name = "@#{name}" instance_variable_set(var_name, other.instance_variable_get(var_name).dup) end end def define_component(object_name, options) @all_components[object_name] = options @all_ordered_components << object_name @selected_components[object_name] = options end def only(selector) dup.send(:only!, selector) end def exclude(selector) dup.send(:exclude!, selector) end def set_namespace(namespace) dup.send(:set_namespace!, namespace) end def set_output_dir(dir) dup.send(:set_output_dir!, dir) end def link_objects result = [] selected_categories.each do \|category\| object_names = selected_objects_belonging_to_category(category) result.concat(object_filenames_for(object_names)) end result end def link_objects_as_string link_objects.join(' ') end def enable_optimizations!(lto = false) @default_optimization_level = "-O" if lto @default_extra_optimization_flags = "-flto" end end def define_tasks(extra_compiler_flags = nil) group_all_components_by_category.each_pair do \|category, object_names\| define_category_tasks(category, object_names, extra_compiler_flags) end task("#{@namespace}:clean") do sh "rm -rf #{@output_dir}" end self end private def define_category_tasks(category, object_names, extra_compiler_flags) object_names.each do \|object_name\| define_object_compilation_task(object_name, extra_compiler_flags) end object_filenames = object_filenames_for(object_names) task "#{@namespace}:clean" do sh "rm -f #{object_filenames.join(' ')}" end end def define_object_compilation_task(object_name, extra_compiler_flags) options = @all_components[object_name] source_file = locate_source_file(options[:source]) object_file = "#{@output_dir}/#{object_name}" case options[:optimize] when :light optimization_level = "-O" when true, :heavy optimization_level = "-O2" when :very_heavy optimization_level = "-O3" when nil optimization_level = @default_optimization_level else raise "Unknown optimization level #{options[:optimize]}" end optimize = "#{optimization_level} #{@default_extra_optimization_flags}".strip if options[:strict_aliasing] == false # and not nil optimize = "#{optimize} -fno-strict-aliasing" # Disable link-time optimization so that we can no-strict-aliasing # works: http://stackoverflow.com/a/25765338/20816 optimize.sub!(/-flto/, "") end define_c_or_cxx_object_compilation_task( object_file, source_file, lambda { { :include_paths => CXX_SUPPORTLIB_INCLUDE_PATHS, :flags => [ libev_cflags, libuv_cflags, optimize, "#{maybe_eval_lambda(extra_compiler_flags)} #{options[:cflags]}".strip ] } } ) end def set_namespace!(namespace) @namespace = namespace return self end def set_output_dir!(dir) @output_dir = dir return self end def only!(selector) new_components = apply_selector(selector) @selected_components = new_components return self end def exclude!(selector) apply_selector(selector).each_key do \|object_name\| @selected_components.delete(object_name) end return self end def apply_selector(selector) result = {} selector = [selector].flatten selector.each do \|condition\| @selected_components.each do \|object_name, options\| if component_satisfies_condition?(object_name, options, condition) result[object_name] = options end end end return result end def component_satisfies_condition?(object_name, options, condition) case condition when Symbol return condition == :all \|\| options[:category] == condition when String return object_name == condition else raise ArgumentError, "Invalid condition #{condition.inspect}" end end def selected_categories categories = {} @selected_components.each_value do \|options\| categories[options[:category]] = true end return categories.keys end def category_complete?(category) expected = 0 actual = 0 @all_components.each_value do \|options\| if options[:category] == category expected += 1 end end @selected_components.each_value do \|options\| if options[:category] == category actual += 1 end end return expected == actual end def selected_objects_belonging_to_category(category) result = [] @selected_components.each_pair do \|object_name, options\| if options[:category] == category result << object_name end end return result end def object_filenames_for(object_names) return object_names.map { \|name\| "#{@output_dir}/#{name}" } end def group_all_components_by_category categories = {} @all_ordered_components.each do \|object_name\| options = @all_components[object_name] category = options[:category] categories[category] \|\|= [] categories[category] << object_name end return categories end def locate_source_file(path) "src/cxx_supportlib/#{path}" end end COMMON_LIBRARY = CommonLibraryBuilder.new do define_component 'LoggingKit.o', :source => 'LoggingKit/Implementation.cpp', :category => :base, :optimize => :very_heavy define_component 'Exceptions.o', :source => 'Exceptions.cpp', :category => :base define_component 'FileTools/PathManip.o', :source => 'FileTools/PathManip.cpp', :category => :base define_component 'FileTools/FileManip.o', :source => 'FileTools/FileManip.cpp', :category => :base define_component 'FileTools/PathSecurityCheck.o', :source => 'FileTools/PathSecurityCheck.cpp', :category => :base define_component 'ProcessManagement/Spawn.o', :source => 'ProcessManagement/Spawn.cpp', :category => :base define_component 'ProcessManagement/Utils.o', :source => 'ProcessManagement/Utils.cpp', :category => :base define_component 'SystemTools/UserDatabase.o', :source => 'SystemTools/UserDatabase.cpp', :category => :base define_component 'Utils/SystemTime.o', :source => 'SystemTools/SystemTime.cpp', :category => :base define_component 'StrIntTools/StrIntUtils.o', :source => 'StrIntTools/StrIntUtils.cpp', :category => :base, :optimize => :very_heavy define_component 'StrIntTools/StrIntUtilsNoStrictAliasing.o', :source => 'StrIntTools/StrIntUtilsNoStrictAliasing.cpp', :category => :base, :optimize => :very_heavy, # Compiling with SSE2 causes segfaults on Amazon Linux 2 :cflags => RbConfig::CONFIG['host_cpu'] == 'x86_64' && RbConfig::CONFIG['host_os'].include?('linux') ? ' -mno-sse2' : '', :strict_aliasing => false define_component 'IOTools/IOUtils.o', :source => 'IOTools/IOUtils.cpp', :optimize => :light, :category => :base define_component 'Algorithms/Hasher.o', :source => 'Algorithms/Hasher.cpp', :category => :base, :optimize => :very_heavy define_component 'Utils.o', :source => 'Utils.cpp', :category => :base define_component 'jsoncpp.o', :source => 'vendor-modified/jsoncpp/jsoncpp.cpp', :category => :base, :optimize => true define_component 'SecurityKit/Crypto.o', :source => 'SecurityKit/Crypto.cpp', :category => :other, :cflags => PhusionPassenger::PlatformInfo.crypto_extra_cflags define_component 'Utils/CachedFileStat.o', :source => 'Utils/CachedFileStat.cpp', :category => :other define_component 'WatchdogLauncher.o', :source => 'WatchdogLauncher.cpp', :category => :other define_component 'MemoryKit/mbuf.o', :source => 'MemoryKit/mbuf.cpp', :category => :other, :optimize => true define_component 'MemoryKit/palloc.o', :source => 'MemoryKit/palloc.cpp', :category => :other, :optimize => true define_component 'ServerKit/url_parser.o', :source => 'ServerKit/url_parser.c', :category => :other, :optimize => :very_heavy define_component 'ServerKit/llhttp.o', :source => 'ServerKit/llhttp.c', :category => :other, :optimize => :very_heavy define_component 'ServerKit/llhttp_http.o', :source => 'ServerKit/llhttp_http.c', :category => :other, :optimize => :very_heavy define_component 'ServerKit/llhttp_api.o', :source => 'ServerKit/llhttp_api.c', :category => :other, :optimize => :very_heavy define_component 'ServerKit/Implementation.o', :source => 'ServerKit/Implementation.cpp', :category => :other, :optimize => true define_component 'DataStructures/LString.o', :source => 'DataStructures/LString.cpp', :category => :other define_component 'AppTypeDetector/CBindings.o', :source => 'AppTypeDetector/CBindings.cpp', :category => :other define_component 'WrapperRegistry/CBindings.o', :source => 'WrapperRegistry/CBindings.cpp', :category => :other define_component 'vendor-modified/modp_b64.o', :source => 'vendor-modified/modp_b64.cpp', :category => :base64, :optimize => true, :strict_aliasing => false define_component 'vendor-modified/modp_b64_strict_aliasing.o', :source => 'vendor-modified/modp_b64_strict_aliasing.cpp', :category => :base64, :optimize => true define_component 'JsonTools/CBindings.o', :source => 'JsonTools/CBindings.cpp', :category => :json_tools define_component 'FileTools/LargeFiles.o', :source => 'FileTools/LargeFiles.cpp', :category => :file_tools_large_files define_component 'FileTools/PathManipCBindings.o', :source => 'FileTools/PathManipCBindings.cpp', :category => :file_tools_path_manip_cbindings define_component 'ProcessManagement/Ruby.o', :source => 'ProcessManagement/Ruby.cpp', :category => :process_management_ruby end # A subset of the objects are linked to the Nginx binary. This defines # what those objects are. NGINX_LIBS_SELECTOR = [:base, 'WatchdogLauncher.o', 'AppTypeDetector/CBindings.o', 'WrapperRegistry/CBindings.o', 'Utils/CachedFileStat.o', 'JsonTools/CBindings.o', 'FileTools/PathManipCBindings.o']	12.34 KB	2025-11-20 11:36
📁 config	-	2026-03-21 15:53
📄 console_text_template.rb # encoding: utf-8 # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2010-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. require 'erb' PhusionPassenger.require_passenger_lib 'utils/ansi_colors' module PhusionPassenger class ConsoleTextTemplate def initialize(input, options = {}) @buffer = '' if input[:file] filename = "#{PhusionPassenger.resources_dir}/templates/#{input[:file]}.txt.erb" data = File.open(filename, 'r:utf-8') do \|f\| f.read end else data = input[:text] end @colors = options[:colors] \|\| AnsiColors.new if RUBY_VERSION >= '2.6' @template = ERB.new(@colors.ansi_colorize(data), trim_mode: '-', eoutvar: '@buffer') else @template = ERB.new(@colors.ansi_colorize(data), nil, '-', '@buffer') end @template.filename = filename if filename options.each_pair do \|name, value\| self[name] = value end end def []=(name, value) instance_variable_set("@#{name}".to_sym, value) return self end def result return @template.result(binding) end end end # module PhusionPassenger	2.29 KB	2025-11-20 11:36
📄 constants.rb # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2010-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 PASSENGER_TXN_ID = "PASSENGER_TXN_ID".freeze PASSENGER_APP_GROUP_NAME = "PASSENGER_APP_GROUP_NAME".freeze PASSENGER_DELTA_MONOTONIC = "PASSENGER_DELTA_MONOTONIC".freeze RACK_HIJACK_IO = "rack.hijack_io".freeze LVL_CRIT = 0 LVL_ERROR = 1 LVL_WARN = 2 LVL_NOTICE = 3 LVL_INFO = 4 LVL_DEBUG = 5 LVL_DEBUG2 = 6 LVL_DEBUG3 = 7 # Constants shared between the C++ and Ruby codebase. The C++ Constants.h # is automatically generated by the build system from the following # definitions. module SharedConstants # Default config values DEFAULT_LOG_LEVEL = 3 DEFAULT_LOG_LEVEL_NAME = "notice" DEFAULT_APP_OUTPUT_LOG_LEVEL = 3 DEFAULT_APP_OUTPUT_LOG_LEVEL_NAME = "notice" DEFAULT_INTEGRATION_MODE = "standalone" DEFAULT_SOCKET_BACKLOG = 2048 DEFAULT_RUBY = "ruby" DEFAULT_PYTHON = "python" DEFAULT_NODEJS = "node" DEFAULT_MAX_POOL_SIZE = 6 DEFAULT_POOL_IDLE_TIME = 300 DEFAULT_MAX_PRELOADER_IDLE_TIME = 5 * 60 DEFAULT_START_TIMEOUT = 90_000 DEFAULT_WEB_APP_USER = "nobody" DEFAULT_APP_ENV = "production" DEFAULT_SPAWN_METHOD = "smart" DEFAULT_BIND_ADDRESS = "127.0.0.1" # Apache's unixd.h also defines DEFAULT_USER, so we avoid naming clash here. PASSENGER_DEFAULT_USER = "nobody" DEFAULT_CONCURRENCY_MODEL = "process" DEFAULT_STICKY_SESSIONS_COOKIE_NAME = "_passenger_route" DEFAULT_STICKY_SESSIONS_COOKIE_ATTRIBUTES = "SameSite=Lax; Secure;" DEFAULT_APP_THREAD_COUNT = 1 DEFAULT_RESPONSE_BUFFER_HIGH_WATERMARK = 1024 * 1024 * 128 DEFAULT_MAX_REQUEST_QUEUE_SIZE = 100 DEFAULT_STAT_THROTTLE_RATE = 10 DEFAULT_ANALYTICS_LOG_USER = DEFAULT_WEB_APP_USER DEFAULT_ANALYTICS_LOG_GROUP = "" DEFAULT_ANALYTICS_LOG_PERMISSIONS = "u=rwx,g=rx,o=rx" DEFAULT_HTTP_SERVER_LISTEN_ADDRESS = "tcp://127.0.0.1:3000" DEFAULT_LVE_MIN_UID = 500 # Size limits MESSAGE_SERVER_MAX_USERNAME_SIZE = 100 MESSAGE_SERVER_MAX_PASSWORD_SIZE = 100 POOL_HELPER_THREAD_STACK_SIZE = 1024 * 256 SPAWNINGKIT_MAX_SUBPROCESS_ERROR_MESSAGE_SIZE = 1024 * 128 SPAWNINGKIT_MAX_SUBPROCESS_ENVDUMP_SIZE = 1024 * 128 SPAWNINGKIT_MAX_PROPERTIES_JSON_SIZE = 1024 * 32 SPAWNINGKIT_MAX_ERROR_CATEGORY_SIZE = 32 SPAWNINGKIT_MAX_JOURNEY_STEP_FILE_SIZE = 32 # Small mbuf sizes avoid memory overhead (up to 1 blocksize per request), but # also introduce context switching and smaller transfer writes. The size is picked # to balance this out. DEFAULT_MBUF_CHUNK_SIZE = 1024 * 4 # Affects input and output buffering (between app and client). Threshold is picked # such that it fits most output (i.e. html page size, not assets), and allows for # high concurrency with low mem overhead. On the upload side there is a penalty # but there's no real average upload size anyway so we choose mem safety instead. DEFAULT_FILE_BUFFERED_CHANNEL_THRESHOLD = 1024 * 128 SERVER_KIT_MAX_SERVER_ENDPOINTS = 4 LOG_MONITORING_MAX_LINES = 200 # Time limits PROCESS_SHUTDOWN_TIMEOUT = 60 # In seconds PROCESS_SHUTDOWN_TIMEOUT_DISPLAY = "1 minute" # Versions PASSENGER_VERSION = PhusionPassenger::VERSION_STRING PASSENGER_API_VERSION_MAJOR = 0 PASSENGER_API_VERSION_MINOR = 3 PASSENGER_API_VERSION = "#{PASSENGER_API_VERSION_MAJOR}.#{PASSENGER_API_VERSION_MINOR}" SERVER_INSTANCE_DIR_STRUCTURE_MAJOR_VERSION = 4 SERVER_INSTANCE_DIR_STRUCTURE_MINOR_VERSION = 0 SERVER_INSTANCE_DIR_STRUCTURE_MIN_SUPPORTED_MINOR_VERSION = 0 # Misc FEEDBACK_FD = 3 PROGRAM_NAME = "Phusion Passenger(R)" SHORT_PROGRAM_NAME = "Passenger" SERVER_TOKEN_NAME = "Phusion_Passenger" FLYING_PASSENGER_NAME = "Flying Passenger" PROGRAM_WEBSITE = "https://www.phusionpassenger.com" PROGRAM_AUTHOR = "Phusion" SUPPORT_URL = "https://www.phusionpassenger.com/support" ENTERPRISE_URL = "https://www.phusionpassenger.com/features#premium-features" GLOBAL_NAMESPACE_DIRNAME = PhusionPassenger::GLOBAL_NAMESPACE_DIRNAME_ # Subdirectory under $HOME to use for storing stuff. USER_NAMESPACE_DIRNAME = PhusionPassenger::USER_NAMESPACE_DIRNAME_ AGENT_EXE = "PassengerAgent" DEB_MAIN_PACKAGE = "passenger" DEB_DEV_PACKAGE = "passenger-dev" DEB_APACHE_MODULE_PACKAGE = "libapache2-mod-passenger" DEB_NGINX_PACKAGE = "nginx-extras" RPM_MAIN_PACKAGE = "passenger" RPM_DEV_PACKAGE = "passenger-devel" RPM_APACHE_MODULE_PACKAGE = "mod_passenger" RPM_NGINX_PACKAGE = "nginx" end SharedConstants.constants.each do \|name\| const_set(name, SharedConstants.const_get(name)) unless const_defined? name end end	5.98 KB	2025-11-20 11:36
📄 debug_logging.rb # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2010-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. PhusionPassenger.require_passenger_lib 'constants' module PhusionPassenger module DebugLogging # We don't refer to STDERR directly because STDERR's reference might # change during runtime. @@log_level = DEFAULT_LOG_LEVEL @@log_device = nil @@log_filename = nil @@stderr_evaluator = lambda { STDERR } def self.included(klass) klass.class_eval do private :debug private :trace end end def self.log_level return @@log_level end def self.log_level=(level) @@log_level = level end def self.log_file=(filename) if filename && filename.empty? @@log_filename = nil else @@log_filename = filename end @@log_device.close if @@log_device && !@@log_device.closed? @@log_device = nil end def self._log_device return @@log_device end def self.stderr_evaluator=(block) if block @@stderr_evaluator = block else @@stderr_evaluator = lambda { STDERR } end end def error(message) _output(1, message, 1) end module_function :error def warn(message) _output(2, message, 1) end module_function :warn def notice(message) _output(3, message, 1) end module_function :notice def info(message) _output(4, message, 1) end module_function :info def debug(message) _output(5, message, 1) end module_function :debug def trace(level, message) _output(4 + level, message, 1) end module_function :trace def _output(level, message, nesting_level = 0) if @@log_level >= level if @@log_filename if !@@log_device \|\| @@log_device.closed? @@log_device = File.open(@@log_filename, "a") end output = @@log_device else output = @@stderr_evaluator.call end location = caller[nesting_level].sub(/.phusion_passenger\//, '') location.sub!(/(.?):.*/, '\1') now = Time.now time_str = now.strftime("%Y-%m-%d %H:%M:%S.") time_str << sprintf("%04d", now.usec / 100) current_thread = Thread.current if !(thread_id = current_thread[:id]) current_thread.to_s =~ /:(0x[0-9a-f]+)/i thread_id = current_thread[:id] = $1 \|\| '?' end if thread_name = current_thread[:name] thread_name = "(#{thread_name})" end output.write("[ #{time_str} #{$$}/#{thread_id}#{thread_name} #{location} ]: #{message}\n") output.flush end end module_function :_output end end	3.84 KB	2025-11-20 11:36
📄 loader_shared_helpers.rb # 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	37.67 KB	2025-11-20 11:36
📄 message_channel.rb # encoding: binary # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2010-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 # This class allows reading and writing structured messages over # I/O channels. This is the Ruby implementation of src/cxx_supportlib/IOTools/MessageIO.h; # see that file for more information. class MessageChannel HEADER_SIZE = 2 # :nodoc: DELIMITER = "\0" # :nodoc: DELIMITER_NAME = "null byte" # :nodoc: UINT16_PACK_FORMAT = "n" # :nodoc: UINT32_PACK_FORMAT = "N" # :nodoc: class InvalidHashError < StandardError end # The wrapped IO object. attr_accessor :io # Create a new MessageChannel by wrapping the given IO object. def initialize(io = nil) @io = io # Make it binary just in case. @io.binmode if @io end # Read an array message from the underlying file descriptor. # Returns the array message as an array, or nil when end-of-stream has # been reached. # # Might raise SystemCallError, IOError or SocketError when something # goes wrong. def read buffer = new_buffer if !@io.read(HEADER_SIZE, buffer) return nil end while buffer.size < HEADER_SIZE tmp = @io.read(HEADER_SIZE - buffer.size) if tmp.empty? return nil else buffer << tmp end end chunk_size = buffer.unpack(UINT16_PACK_FORMAT)[0] if !@io.read(chunk_size, buffer) return nil end while buffer.size < chunk_size tmp = @io.read(chunk_size - buffer.size) if tmp.empty? return nil else buffer << tmp end end message = [] offset = 0 delimiter_pos = buffer.index(DELIMITER, offset) while !delimiter_pos.nil? if delimiter_pos == 0 message << "" else message << buffer[offset .. delimiter_pos - 1] end offset = delimiter_pos + 1 delimiter_pos = buffer.index(DELIMITER, offset) end return message rescue Errno::ECONNRESET return nil end # Read an array message from the underlying file descriptor and return the # result as a hash instead of an array. This assumes that the array message # has an even number of elements. # Returns nil when end-of-stream has been reached. # # Might raise SystemCallError, IOError or SocketError when something # goes wrong. def read_hash buffer = new_buffer if !@io.read(HEADER_SIZE, buffer) return nil end while buffer.size < HEADER_SIZE tmp = @io.read(HEADER_SIZE - buffer.size) if tmp.empty? return nil else buffer << tmp end end chunk_size = buffer.unpack(UINT16_PACK_FORMAT)[0] if !@io.read(chunk_size, buffer) return nil end while buffer.size < chunk_size tmp = @io.read(chunk_size - buffer.size) if tmp.empty? return nil else buffer << tmp end end result = {} offset = 0 delimiter_pos = buffer.index(DELIMITER, offset) while !delimiter_pos.nil? if delimiter_pos == 0 name = "" else name = buffer[offset .. delimiter_pos - 1] end offset = delimiter_pos + 1 delimiter_pos = buffer.index(DELIMITER, offset) if delimiter_pos.nil? raise InvalidHashError elsif delimiter_pos == 0 value = "" else value = buffer[offset .. delimiter_pos - 1] end result[name] = value offset = delimiter_pos + 1 delimiter_pos = buffer.index(DELIMITER, offset) end return result rescue Errno::ECONNRESET return nil end # Read a scalar message from the underlying IO object. Returns the # read message, or nil on end-of-stream. # # Might raise SystemCallError, IOError or SocketError when something # goes wrong. # # The +buffer+ argument specifies a buffer in which #read_scalar # stores the read data. It is good practice to reuse existing buffers # in order to minimize stress on the garbage collector. # # The +max_size+ argument allows one to specify the maximum allowed # size for the scalar message. If the received scalar message's size # is larger than +max_size+, then a SecurityError will be raised. def read_scalar(buffer = new_buffer, max_size = nil) if !@io.read(4, buffer) return nil end while buffer.size < 4 tmp = @io.read(4 - buffer.size) if tmp.empty? return nil else buffer << tmp end end size = buffer.unpack(UINT32_PACK_FORMAT)[0] if size == 0 buffer.replace('') return buffer else if !max_size.nil? && size > max_size raise SecurityError, "Scalar message size (#{size}) " << "exceeds maximum allowed size (#{max_size})." end if !@io.read(size, buffer) return nil end if buffer.size < size tmp = '' while buffer.size < size if !@io.read(size - buffer.size, tmp) return nil else buffer << tmp end end end return buffer end rescue Errno::ECONNRESET return nil end # Send an array message, which consists of the given elements, over the underlying # file descriptor. _name_ is the first element in the message, and _args_ are the # other elements. These arguments will internally be converted to strings by calling # to_s(). # # Might raise SystemCallError, IOError or SocketError when something # goes wrong. def write(name, args) check_argument(name) args.each do \|arg\| check_argument(arg) end message = "#{name}#{DELIMITER}" args.each do \|arg\| message << arg.to_s << DELIMITER end if message.size > 2 * 16 - 1 raise ArgumentError, 'Message size too large' end @io.write([message.size].pack('n') << message) @io.flush end # Send a scalar message over the underlying IO object. # # Might raise SystemCallError, IOError or SocketError when something # goes wrong. def write_scalar(data) @io.write([data.size].pack('N') << data) @io.flush end # Receive an IO object (a file descriptor) from the channel. The other # side must have sent an IO object by calling send_io(). Note that # this only works on Unix sockets. # # Might raise SystemCallError, IOError or SocketError when something # goes wrong. def recv_io(klass = IO, negotiate = true) write("pass IO") if negotiate io = @io.recv_io(klass) write("got IO") if negotiate return io end # Send an IO object (a file descriptor) over the channel. The other # side must receive the IO object by calling recv_io(). Note that # this only works on Unix sockets. # # Might raise SystemCallError, IOError or SocketError when something # goes wrong. def send_io(io) # We read a message before actually calling #send_io # in order to prevent the other side from accidentally # read()ing past the normal data and reading our file # descriptor too. # # For example suppose that side A looks like this: # # read(fd, buf, 1024) # read_io(fd) # # and side B: # # write(fd, buf, 100) # send_io(fd_to_pass) # # If B completes both write() and send_io(), then A's read() call # reads past the 100 bytes that B sent. On some platforms, like # Linux, this will cause read_io() to fail. And it just so happens # that Ruby's IO#read method slurps more than just the given amount # of bytes. result = read if !result raise EOFError, "End of stream" elsif result != ["pass IO"] raise IOError, "IO passing pre-negotiation header expected" else @io.send_io(io) # Once you've sent the IO you expect to be able to close it on the # sender's side, even if the other side hasn't read the IO yet. # Not so: on some operating systems (I'm looking at you OS X) this # can cause the receiving side to receive a bad file descriptor. # The post negotiation protocol ensures that we block until the # other side has really received the IO. result = read if !result raise EOFError, "End of stream" elsif result != ["got IO"] raise IOError, "IO passing post-negotiation header expected" end end end # Return the file descriptor of the underlying IO object. def fileno return @io.fileno end # Close the underlying IO stream. Might raise SystemCallError or # IOError when something goes wrong. def close @io.close end # Checks whether the underlying IO stream is closed. def closed? return @io.closed? end private def check_argument(arg) if arg.to_s.index(DELIMITER) raise ArgumentError, "Message name and arguments may not contain #{DELIMITER_NAME}." end end if defined?(ByteString) def new_buffer return ByteString.new end else def new_buffer return "" end end end end # module PhusionPassenger	10.6 KB	2025-11-20 11:36
📄 message_client.rb # encoding: binary # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2010-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. require 'socket' PhusionPassenger.require_passenger_lib 'message_channel' PhusionPassenger.require_passenger_lib 'utils' module PhusionPassenger # A convenience class for communicating with MessageServer servers, # for example the ApplicationPool server. class MessageClient include Utils class ProtocolError < StandardError end # Connect to the given server. By default it connects to the current # generation's core. def initialize(username, password, address) @socket = connect_to_server(address) begin @channel = MessageChannel.new(@socket) result = @channel.read if result.nil? raise EOFError elsif result.size != 2 \|\| result[0] != "version" raise IOError, "The message server didn't sent a valid version identifier" elsif result[1] != "1" raise IOError, "Unsupported message server protocol version #{result[1]}" end @channel.write_scalar(username) @channel.write_scalar(password) result = @channel.read if result.nil? raise EOFError elsif result[0] != "status" raise ProtocolError, "Invalid authentication response: expected \"status\", got #{result[0].inspect}" elsif result[1] == "ok" # Do nothing elsif result[1] == "error" if result[2] raise SecurityError, "Authentication error: #{result[2]}" else raise SecurityError, "Authentication error (no server message given)" end else raise ProtocolError, "Invalid authentication response: #{result.inspect}" end rescue Exception @socket.close raise end end def close @socket.close if @socket @channel = @socket = nil end def connected? return !!@channel end ### Low level I/O methods ### def read return @channel.read rescue auto_disconnect raise end def write(args) @channel.write(args) rescue auto_disconnect raise end def write_scalar(args) @channel.write_scalar(args) rescue auto_disconnect raise end def read_scalar return @channel.read_scalar rescue auto_disconnect raise end def recv_io(klass = IO, negotiate = true) return @channel.recv_io(klass, negotiate) rescue auto_disconnect raise end private def auto_disconnect if @channel @socket.close rescue nil @socket = @channel = nil end end end end # module PhusionPassenger	3.86 KB	2025-11-20 11:36
📄 native_support.rb # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2010-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. PhusionPassenger.require_passenger_lib 'constants' module PhusionPassenger class NativeSupportLoader def self.supported? return !defined?(RUBY_ENGINE) \|\| RUBY_ENGINE == "ruby" \|\| RUBY_ENGINE == "rbx" end def try_load if defined?(NativeSupport) return true else load_from_native_support_output_dir \|\| load_from_buildout_dir \|\| load_from_load_path \|\| load_from_home_dir end end def start if ENV['PASSENGER_USE_RUBY_NATIVE_SUPPORT'] == '0' STDERR.puts " [#{library_name}] will not be used (PASSENGER_USE_RUBY_NATIVE_SUPPORT=0)" STDERR.puts " --> Passenger will still operate normally." return false elsif try_load return true elsif compile_and_load \|\| download_binary_and_load STDERR.puts " [#{library_name}] successfully loaded." return true else STDERR.puts " [#{library_name}] will not be used (can't compile or download) " STDERR.puts " --> Passenger will still operate normally." return false end end private def archdir @archdir \|\|= begin PhusionPassenger.require_passenger_lib 'platform_info/binary_compatibility' PlatformInfo.ruby_extension_binary_compatibility_id end end def libext @libext \|\|= begin PhusionPassenger.require_passenger_lib 'platform_info/operating_system' PlatformInfo.library_extension end end def library_name return "passenger_native_support.#{libext}" end def extconf_rb File.join(PhusionPassenger.ruby_extension_source_dir, "extconf.rb") end def load_from_native_support_output_dir # Quick workaround for people suffering from # https://code.google.com/p/phusion-passenger/issues/detail?id=865 output_dir = ENV['PASSENGER_NATIVE_SUPPORT_OUTPUT_DIR'] if output_dir && !output_dir.empty? begin return load_native_extension("#{output_dir}/#{VERSION_STRING}/#{archdir}/#{library_name}") rescue LoadError return false end else return false end end def load_from_buildout_dir if PhusionPassenger.build_system_dir begin return load_native_extension("#{PhusionPassenger.build_system_dir}/buildout/ruby/#{archdir}/#{library_name}") rescue LoadError return false end else return false end end def load_from_load_path return load_native_extension('passenger_native_support') rescue LoadError return false end def load_from_home_dir begin return load_native_extension("#{PhusionPassenger.home_dir}/#{USER_NAMESPACE_DIRNAME}/native_support/#{VERSION_STRING}/#{archdir}/#{library_name}") rescue LoadError return false end end def download_binary_and_load if !PhusionPassenger.installed_from_release_package? STDERR.puts " [#{library_name}] not downloading because passenger wasn't installed from a release package" return end if ENV['PASSENGER_DOWNLOAD_NATIVE_SUPPORT_BINARY'] == '0' STDERR.puts " [#{library_name}] not downloading because PASSENGER_DOWNLOAD_NATIVE_SUPPORT_BINARY=0" return end STDERR.puts " [#{library_name}] finding downloads for the current Ruby interpreter..." STDERR.puts " (set PASSENGER_DOWNLOAD_NATIVE_SUPPORT_BINARY=0 to disable)" require 'logger' PhusionPassenger.require_passenger_lib 'platform_info/ruby' PhusionPassenger.require_passenger_lib 'utils/tmpio' PhusionPassenger.require_passenger_lib 'utils/download' PhusionPassenger.require_passenger_lib 'utils/shellwords' PhusionPassenger::Utils.mktmpdir("passenger-native-support-") do \|dir\| Dir.chdir(dir) do basename = "rubyext-#{archdir}.tar.gz" if !download(basename, dir, :total_timeout => 30) return false end s_basename = Shellwords.escape(basename) sh "tar xzf #{s_basename}" sh "rm -f #{s_basename}" STDERR.puts " Checking whether downloaded binary is usable..." File.open("test.rb", "w") do \|f\| f.puts(%Q{ require File.expand_path('passenger_native_support') f = File.open("test.txt", "w") PhusionPassenger::NativeSupport.writev(f.fileno, ["hello", "\n"]) }) end if sh_nonfatal("#{PlatformInfo.ruby_command} -I. test.rb") && File.exist?("test.txt") && File.read("test.txt") == "hello\n" STDERR.puts " Binary is usable." File.unlink("test.rb") File.unlink("test.txt") result = try_directories(installation_target_dirs) do \|target_dir\| files = Dir["#{dir}/*"] STDERR.puts " Installing " + files.map{ \|n\| File.basename(n) }.join(' ') FileUtils.cp(files, target_dir) load_result = load_native_extension("#{target_dir}/#{library_name}") [load_result, false] end return result else STDERR.puts " Binary is not usable." return false end end end end def compile_and_load if ENV['PASSENGER_COMPILE_NATIVE_SUPPORT_BINARY'] == '0' STDERR.puts " [#{library_name}] not compiling because PASSENGER_COMPILE_NATIVE_SUPPORT_BINARY=0" return false end if PhusionPassenger.custom_packaged? && !File.exist?(PhusionPassenger.ruby_extension_source_dir) PhusionPassenger.require_passenger_lib 'constants' STDERR.puts " [#{library_name}] not found for current Ruby interpreter." case PhusionPassenger.packaging_method when 'deb' STDERR.puts " This library provides various optimized routines that make" STDERR.puts " #{PhusionPassenger::PROGRAM_NAME} faster. Please run 'sudo apt-get install #{PhusionPassenger::DEB_DEV_PACKAGE}'" STDERR.puts " so that #{PhusionPassenger::PROGRAM_NAME} can compile one on the next run." when 'rpm' STDERR.puts " This library provides various optimized routines that make" STDERR.puts " #{PhusionPassenger::PROGRAM_NAME} faster. Please run 'sudo yum install #{PhusionPassenger::RPM_DEV_PACKAGE}-#{PhusionPassenger::VERSION_STRING}'" STDERR.puts " so that #{PhusionPassenger::PROGRAM_NAME} can compile one on the next run." else STDERR.puts " #{PhusionPassenger::PROGRAM_NAME} can compile one, but an extra package must be installed" STDERR.puts " first. Please ask your packager or operating system vendor for instructions." end return false end STDERR.puts " [#{library_name}] trying to compile for the current user (#{current_user_name_or_id}) and Ruby interpreter..." STDERR.puts " (set PASSENGER_COMPILE_NATIVE_SUPPORT_BINARY=0 to disable)" require 'fileutils' PhusionPassenger.require_passenger_lib 'utils/shellwords' PhusionPassenger.require_passenger_lib 'platform_info/ruby' target_dir = compile(installation_target_dirs) if target_dir return load_native_extension("#{target_dir}/#{library_name}") else return false end end # Name of the user under which we are executing, or the id as fallback # N.B. loader_shared_helpers.rb has the same method def current_user_name_or_id require 'etc' if !defined?(Etc) begin user = Etc.getpwuid(Process.uid) rescue ArgumentError user = nil end if user return user.name else return "##{Process.uid}" end end def installation_target_dirs target_dirs = [] if (output_dir = ENV['PASSENGER_NATIVE_SUPPORT_OUTPUT_DIR']) && !output_dir.empty? target_dirs << "#{output_dir}/#{VERSION_STRING}/#{archdir}" end if PhusionPassenger.build_system_dir target_dirs << "#{PhusionPassenger.build_system_dir}/buildout/ruby/#{archdir}" end target_dirs << "#{PhusionPassenger.home_dir}/#{USER_NAMESPACE_DIRNAME}/native_support/#{VERSION_STRING}/#{archdir}" return target_dirs end def download(name, output_dir, options = {}) logger = Logger.new(STDERR) logger.level = Logger::WARN logger.formatter = proc do \|severity, datetime, progname, msg\| msg.gsub(/^/, " ") + "\n" end sites = PhusionPassenger.binaries_sites sites.each_with_index do \|site, i\| if real_download(site, name, output_dir, logger, options) logger.warn "Download OK!" if i > 0 return true elsif i != sites.size - 1 logger.warn "Trying next mirror..." end end return false end def real_download(site, name, output_dir, logger, options) if site[:url].include?('{{VERSION}}') url = site[:url].gsub('{{VERSION}}', VERSION_STRING) + "/#{name}" else url = "#{site[:url]}/#{VERSION_STRING}/#{name}" end filename = "#{output_dir}/#{name}" real_options = options.merge( :cacert => site[:cacert], :use_cache => true, :logger => logger ) return PhusionPassenger::Utils::Download.download(url, filename, real_options) end def log(message, options = {}) if logger = options[:logger] logger.puts(message) else STDERR.puts " #{message}" end end def mkdir(dir, options = {}) begin log("# mkdir -p #{dir}", options) FileUtils.mkdir_p(dir) rescue Errno::EEXIST end end def sh(command_string) if !sh_nonfatal(command_string) raise "Could not compile #{library_name} (\"#{command_string}\" failed)" end end def sh_nonfatal(command_string, options = {}) log("# #{command_string}", options) if logger = options[:logger] s_logpath = Shellwords.escape(logger.path) return system("(#{command_string}) >>#{s_logpath} 2>&1") else Utils.mktmpdir("passenger-native-support-") do \|tmpdir\| s_tmpdir = Shellwords.escape(tmpdir) result = system("(#{command_string}) >#{s_tmpdir}/log 2>&1") system("cat #{s_tmpdir}/log \| sed 's/^/ /' >&2") return result end end end def compile(target_dirs) logger = Utils::TmpIO.new('passenger_native_support', :mode => File::WRONLY \| File::APPEND, :binary => false, :suffix => ".log", :unlink_immediately => false) options = { :logger => logger } begin result = try_directories(target_dirs, options) do \|target_dir\| make_result = nil # Perform the actual compilation in a temporary directory to avoid # problems with multiple processes trying to concurrently compile. # https://github.com/phusion/passenger/issues/1570 PhusionPassenger::Utils.mktmpdir("passenger-native-support-") do \|tmpdir\| Dir.chdir(tmpdir) do make_result = sh_nonfatal("#{PlatformInfo.ruby_command} #{Shellwords.escape extconf_rb}", options) && sh_nonfatal("make", options) if make_result begin FileUtils.cp_r(".", target_dir) rescue SystemCallError => e log("Error: #{e}") make_result = false end end end end if make_result log "Compilation successful. The logs are here:" log logger.path [target_dir, false] else [nil, false] end end if !result log "Warning: compilation didn't succeed. To learn why, read this file:" log logger.path end return result end ensure logger.close if logger end def try_directories(dirs, options = {}) result = nil log("# current user is: #{current_user_name_or_id}", options) dirs.each_with_index do \|dir, i\| begin mkdir(dir, options) File.open("#{dir}/.permission_test", "w").close File.unlink("#{dir}/.permission_test") log("# cd #{dir}", options) Dir.chdir(dir) do result, should_retry = yield(dir) return result if !should_retry end rescue Errno::EACCES # If we encountered a permission error, then try # the next target directory. If we get a permission # error on the last one too then propagate the # exception. if i == dirs.size - 1 log("Encountered permission error, " + "but no more directories to try. Giving up.", options) log("-------------------------------", options) return nil else log("Encountered permission error, " + "trying a different directory...", options) log("-------------------------------", options) end rescue Errno::ENOTDIR # This can occur when locations.ini set build_system_dir # to an invalid path. Just ignore this error. if i == dirs.size - 1 log("Not a valid directory, " + "but no more directories to try. Giving up.", options) log("-------------------------------", options) return nil else log("Not a valid directory. Trying a different one...", options) log("-------------------------------", options) end end end end def load_native_extension(name_or_filename) # If passenger_native_support.so exited because it detected that it was compiled # for a different Ruby version, then subsequent require("passenger_native_support") # calls will do nothing. So we remove passenger_native_support from $LOADED_FEATURES # to force it to be loaded. $LOADED_FEATURES.reject! { \|fn\| File.basename(fn) == library_name } begin require(name_or_filename) return defined?(PhusionPassenger::NativeSupport) rescue LoadError => e begin s = e.to_s s = s.encode("US-ASCII", :invalid => :replace) if s.respond_to?(:encode) if s =~ /dlopen/ # Print dlopen failures. We're not interested in any other # kinds of failures, such as file-not-found. puts s.gsub(/^/, " ") end return false rescue EncodingError end end end end end # module PhusionPassenger if PhusionPassenger::NativeSupportLoader.supported? PhusionPassenger::NativeSupportLoader.new.start end	15.96 KB	2025-11-20 11:36
📁 nginx	-	2026-03-21 15:53
📄 packaging.rb # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2010-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 module Packaging # Files that must be generated before packaging. PREGENERATED_FILES = [ 'src/cxx_supportlib/Constants.h' ] USER_EXECUTABLES = [ 'passenger', 'passenger-install-apache2-module', 'passenger-install-nginx-module', 'passenger-config' ] SUPER_USER_EXECUTABLES = [ 'passenger-status', 'passenger-memory-stats' ] # Used during native packaging. Specifies executables for # which the shebang should NOT be set to #!/usr/bin/ruby, # so that these executables can be run with any Ruby interpreter # the user desires. EXECUTABLES_WITH_FREE_RUBY = [ 'passenger', 'passenger-config', 'passenger-install-apache2-module', 'passenger-install-nginx-module' ] # A list of globs which match all files that should be packaged # in the Phusion Passenger gem or tarball. GLOB = [ 'configure', 'Rakefile', 'README.md', 'CONTRIBUTORS', 'CONTRIBUTING.md', 'LICENSE', 'CHANGELOG', 'INSTALL.md', 'NEWS', 'package.json', 'passenger.gemspec', 'build/*/', 'bin/', 'doc//', 'images/', 'man/', # Only inlcude the top-level scripts, required by e.g. the Homebrew packaging. 'dev/', 'src//', 'resources/*/', 'resources/templates/error_renderer/.editorconfig' ] # Files that should be excluded from the gem or tarball. Overrides GLOB. # # This is not merely an exclusion list on top of GLOB! All files that you # do not want to include in the package must be explicitly specified here! # Otherwise source_packaging_test.rb will complain. EXCLUDE_GLOB = [ '/.DS_Store', '/.gch', '/.editorconfig', '/.clangd', '.externalToolBuilders//', '.github/*/', '.settings/*/', '.vscode/*/', '.cproject', 'compile_commands.json', '.gitattributes', '.gitignore', '.gitmodules', '.project', 'CODE_OF_CONDUCT.md', 'Gemfile', 'Gemfile.lock', 'Jenkinsfile', 'Passenger.sublime-project', 'Vagrantfile', 'package-lock.json', 'build/support/vendor//.', 'build/support/vendor//spec//', 'dev///', 'packaging/*/', 'src/ruby_supportlib/phusion_passenger/vendor//.', 'src/ruby_supportlib/phusion_passenger/vendor//hacking//', 'src/ruby_supportlib/phusion_passenger/vendor//spec//', 'src/cxx_supportlib/vendor-copy//.', 'test/*/' ] def self.files result = Dir[GLOB] - Dir[EXCLUDE_GLOB] result.reject! { \|path\| path =~ %r{/\.\.?$} } result end end end # module PhusionPassenger	4.01 KB	2025-11-20 11:36
📁 platform_info	-	2026-03-21 15:53
📄 platform_info.rb # encoding: binary # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2010-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. PhusionPassenger.require_passenger_lib 'utils/tmpio' module PhusionPassenger # This module autodetects various platform-specific information, and # provides that information through constants. module PlatformInfo private @@cache_dir = nil @@verbose = ['1', 'true', 'on', 'yes'].include?(ENV['VERBOSE']) @@log_implementation = lambda do \|message\| message = reindent(message, 3) message.sub!(/^ /, '') STDERR.puts " * #{message}" end def self.private_class_method(name) metaclass = class << self; self; end metaclass.send(:private, name) end private_class_method :private_class_method # Turn the specified class method into a memoized one. If the given # class method is called without arguments, then its result will be # memoized, frozen, and returned upon subsequent calls without arguments. # Calls with arguments are never memoized. # # If +cache_to_disk+ is true and a cache directory has been set with # <tt>PlatformInfo.cache_dir=</tt> then result is cached to a file on disk, # so that memoized results persist over multiple process runs. This # cache file expires in +cache_time+ seconds (1 hour by default) after # it has been written. # # def self.foo(max = 10) # rand(max) # end # memoize :foo # # foo # => 3 # foo # => 3 # foo(100) # => 49 # foo(100) # => 26 # foo # => 3 def self.memoize(method, cache_to_disk = false, cache_time = 3600) # We use class_eval here because Ruby 1.8.5 doesn't support class_variable_get/set. metaclass = class << self; self; end metaclass.send(:alias_method, "_unmemoized_#{method}", method) variable_name = "@@memoized_#{method}".sub(/\?/, '') check_variable_name = "@@has_memoized_#{method}".sub(/\?/, '') eval(%Q{ #{variable_name} = nil #{check_variable_name} = false }) line = __LINE__ + 1 source = %Q{ def self.#{method}(args) # def self.httpd(args) if args.empty? # if args.empty? if !#{check_variable_name} # if !@@has_memoized_httpd if @@cache_dir # if @@cache_dir cache_file = File.join(@@cache_dir, "#{method}") # cache_file = File.join(@@cache_dir, "httpd") end # end read_from_cache_file = false # read_from_cache_file = false if #{cache_to_disk} && cache_file && File.exist?(cache_file) # if #{cache_to_disk} && File.exist?(cache_file) cache_file_stat = File.stat(cache_file) # cache_file_stat = File.stat(cache_file) read_from_cache_file = # read_from_cache_file = Time.now - cache_file_stat.mtime < #{cache_time} # Time.now - cache_file_stat.mtime < #{cache_time} end # end if read_from_cache_file # if read_from_cache_file data = File.read(cache_file) # data = File.read(cache_file) #{variable_name} = Marshal.load(data).freeze # @@memoized_httpd = Marshal.load(data).freeze #{check_variable_name} = true # @@has_memoized_httpd = true else # else #{variable_name} = _unmemoized_#{method}.freeze # @@memoized_httpd = _unmemoized_httpd.freeze #{check_variable_name} = true # @@has_memoized_httpd = true if cache_file && #{cache_to_disk} # if cache_file && #{cache_to_disk} begin # begin if !File.directory?(@@cache_dir) # if !File.directory?(@@cache_dir) FileUtils.mkdir_p(@@cache_dir) # FileUtils.mkdir_p(@@cache_dir) end # end File.open(cache_file, "wb") do \|f\| # File.open(cache_file, "wb") do \|f\| f.write(Marshal.dump(#{variable_name})) # f.write(Marshal.dump(@@memoized_httpd)) end # end rescue Errno::EACCES # rescue Errno::EACCES # Ignore permission error. # # Ignore permission error. end # end end # end end # end end # end #{variable_name} # @@memoized_httpd else # else _unmemoized_#{method}(args) # _unmemoized_httpd(args) end # end end # end } class_eval(source, __FILE__, line) end private_class_method :memoize # Look in the directory +dir+ and check whether there's an executable # whose base name is equal to one of the elements in +possible_names+. # If so, returns the full filename. If not, returns nil. def self.select_executable(dir, possible_names) possible_names.each do \|name\| filename = "#{dir}/#{name}" if File.file?(filename) && File.executable?(filename) return filename end end return nil end private_class_method :select_executable def self.unindent(str) str = str.dup str.gsub!(/\A([\s\t]\n)+/, '') str.gsub!(/[\s\t\n]+\Z/, '') indent = str.split("\n").select{ \|line\| !line.strip.empty? }.map{ \|line\| line.index(/[^\s]/) }.compact.min \|\| 0 str.gsub!(/^[[:blank:]]{#{indent}}/, '') return str end private_class_method :unindent def self.reindent(str, level) str = unindent(str) str.gsub!(/^/, ' ' * level) return str end private_class_method :reindent def self.create_temp_file(name, dir = tmpdir) # This function is mostly used for compiling C programs to autodetect # system properties. We create a secure temp subdirectory to prevent # TOCTU attacks, especially because we don't know how the compiler # handles this. PhusionPassenger::Utils.mktmpdir("passenger.", dir) do \|subdir\| filename = "#{subdir}/#{name}" f = File.open(filename, "w") begin yield(filename, f) ensure f.close if !f.closed? end end end private_class_method :create_temp_file def self.log(message) if verbose? @@log_implementation.call(message) end end private_class_method :log public class RuntimeError < ::RuntimeError end def self.cache_dir=(value) @@cache_dir = value end def self.cache_dir return @@cache_dir end def self.verbose=(val) @@verbose = val end def self.verbose? return @@verbose end def self.log_implementation=(impl) @@log_implementation = impl end def self.log_implementation return @@log_implementation end def self.env_defined?(name) return !ENV[name].nil? && !ENV[name].empty? end def self.string_env(name, default_value = nil) value = ENV[name] if value.nil? \|\| value.empty? return default_value else return value end end def self.read_file(filename) return File.open(filename, "rb") do \|f\| f.read end rescue return "" end # Clears all memoized values. However, the disk cache (if any is configured) # is still used. def self.clear_memoizations class_variables.each do \|name\| if name.to_s =~ /^@@has_memoized_/ class_variable_set(name, false) end end end def self.tmpdir result = ENV['TMPDIR'] if result && !result.empty? return result.sub(/\/+\Z/, '') else return '/tmp' end end memoize :tmpdir # Returns the directory in which test executables should be placed. The # returned directory is guaranteed to be writable and guaranteed to # not be mounted with the 'noexec' option. # If no such directory can be found then it will raise a PlatformInfo::RuntimeError # with an appropriate error message. def self.tmpexedir basename = "test-exe.#{Process.pid}.#{Thread.current.object_id}" attempts = [] dir = tmpdir filename = "#{dir}/#{basename}" begin File.open(filename, 'w') do \|f\| f.chmod(0700) f.puts("#!/bin/sh") end if system(filename) return dir else attempts << { :dir => dir, :error => "This directory's filesystem is mounted with the 'noexec' option." } end rescue Errno::ENOENT attempts << { :dir => dir, :error => "This directory doesn't exist." } rescue Errno::EACCES attempts << { :dir => dir, :error => "This program doesn't have permission to write to this directory." } rescue SystemCallError => e attempts << { :dir => dir, :error => e.message } ensure File.unlink(filename) rescue nil end dir = Dir.pwd filename = "#{dir}/#{basename}" begin File.open(filename, 'w') do \|f\| f.chmod(0700) f.puts("#!/bin/sh") end if system(filename) return dir else attempts << { :dir => dir, :error => "This directory's filesystem is mounted with the 'noexec' option." } end rescue Errno::ENOENT attempts << { :dir => dir, :error => "This directory doesn't exist." } rescue Errno::EACCES attempts << { :dir => dir, :error => "This program doesn't have permission to write to this directory." } rescue SystemCallError => e attempts << { :dir => dir, :error => e.message } ensure File.unlink(filename) rescue nil end message = "ERROR: Cannot find suitable temporary directory\n" + "In order to run certain tests, this program " + "must be able to write temporary\n" + "executable files to some directory. However no such " + "directory can be found. \n" + "The following directories have been tried:\n\n" attempts.each do \|attempt\| message << " * #{attempt[:dir]}\n" message << " #{attempt[:error]}\n" end message << "\nYou can solve this problem by telling this program what directory to write\n" << "temporary executable files to, as follows:\n" << "\n" << " Set the $TMPDIR environment variable to the desired directory's filename and\n" << " re-run this program.\n" << "\n" << "Notes:\n" << "\n" << " * If you're using 'sudo'/'rvmsudo', remember that 'sudo'/'rvmsudo' unsets all\n" << " environment variables, so you must set the environment variable after\n" << " having gained root privileges.\n" << " * The directory you choose must writeable and must not be mounted with the\n" << " 'noexec' option." raise RuntimeError, message end memoize :tmpexedir def self.rb_config if defined?(::RbConfig) return ::RbConfig::CONFIG else return ::Config::CONFIG end end # Check whether the specified command is in $PATH, and return its # absolute filename. Returns nil if the command is not found. # # This function exists because system('which') doesn't always behave # correctly, for some weird reason. # # When `is_executable` is true, this function checks whether # there is an executable named `name` in $PATH. When false, it # assumes that `name` is not an executable name but a command string # (e.g. "ccache gcc"). It then infers the executable name ("ccache") # from the command string, and checks for that instead. def self.find_command(name, is_executable = true) name = name.to_s if !is_executable && name =~ / / name = name.sub(/ ./, '') end if name =~ /^\// if File.executable?(name) return name else return nil end else ENV['PATH'].to_s.split(File::PATH_SEPARATOR).each do \|directory\| next if directory.empty? path = File.join(directory, name) if File.file?(path) && File.executable?(path) return path end end return nil end end def self.find_all_commands(name) search_dirs = ENV['PATH'].to_s.split(File::PATH_SEPARATOR) search_dirs.concat(%w(/bin /sbin /usr/bin /usr/sbin /usr/local/bin /usr/local/sbin)) ["/opt//bin", "/opt//sbin", "/usr/local//bin", "/usr/local//sbin"].each do \|glob\| search_dirs.concat(Dir[glob]) end # Solaris systems may have Apache installations in # /usr/apache2/2.2/bin/sparcv9/ Dir["/usr/apache2//bin"].each do \|bindir\| search_dirs << bindir Dir["#{bindir}/*"].each do \|binsubdir\| if File.directory?(binsubdir) search_dirs << binsubdir end end end search_dirs.delete("") search_dirs.uniq! result = [] search_dirs.each do \|directory\| path = File.join(directory, name) if !File.exist?(path) log "Looking for #{path}: not found" elsif !File.file?(path) log "Looking for #{path}: found, but is not a file" elsif !File.executable?(path) log "Looking for #{path}: found, but is not executable" else log "Looking for #{path}: found" result << path end end return result end # Check whether the specified command is in $PATH or in # /sbin:/usr/sbin:/usr/local/sbin (in case these aren't already in $PATH), # and return its absolute filename. Returns nil if the command is not # found. def self.find_system_command(name) result = find_command(name) if result.nil? ['/sbin', '/usr/sbin', '/usr/local/sbin'].each do \|dir\| path = File.join(dir, name) if File.file?(path) && File.executable?(path) return path end end end result end end end # module PhusionPassenger	16.71 KB	2025-11-20 11:36
📄 plugin.rb # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2010-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. require 'etc' module PhusionPassenger class Plugin @@hooks = {} @@classes = {} def self.load(name, load_once = true) PLUGIN_DIRS.each do \|plugin_dir\| if plugin_dir =~ /\A~/ # File.expand_path uses ENV['HOME'] which we don't want. home = Etc.getpwuid(Process.uid).dir plugin_dir = plugin_dir.sub(/\A~/, home) end plugin_dir = File.expand_path(plugin_dir) Dir["#{plugin_dir}//#{name}.rb"].each do \|filename\| if load_once require(filename) else load(filename) end end end end def self.register_hook(name, &block) hooks_list = (@@hooks[name] \|\|= []) hooks_list << block end def self.call_hook(name, args, &block) last_result = nil if (hooks_list = @@hooks[name]) hooks_list.each do \|callback\| last_result = callback.call(args, &block) end end return last_result end def self.register(name, klass) classes = (@@classes[name] \|\|= []) classes << klass end def initialize(name, args, &block) Plugin.load(name) classes = @@classes[name] if classes @instances = classes.map do \|klass\| klass.new(args, &block) end else return nil end end def call_hook(name, args, &block) last_result = nil if @instances @instances.each do \|instance\| if instance.respond_to?(name.to_sym) last_result = instance.__send__(name.to_sym, *args, &block) end end end return last_result end end end # module PhusionPassenger	2.92 KB	2025-11-20 11:36
📄 preloader_shared_helpers.rb # 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. require 'tmpdir' PhusionPassenger.require_passenger_lib 'constants' PhusionPassenger.require_passenger_lib 'utils' PhusionPassenger.require_passenger_lib 'native_support' module PhusionPassenger # Provides shared functions for preloader apps. module PreloaderSharedHelpers extend self def init(main_app) options = LoaderSharedHelpers.init(main_app) LoaderSharedHelpers.rename_process pre_name(options) if !Kernel.respond_to?(:fork) message = "Smart spawning is not available on this Ruby " + "implementation because it does not support `Kernel.fork`. " case options['integration_mode'] when 'nginx' message << "Please set `passenger_spawn_method` to `direct`." when 'apache' message << "Please set `PassengerSpawnMethod` to `direct`." else message << "Please set `spawn_method` to `direct`." end raise(message) end options end def accept_and_process_next_client(server_socket, options) client = server_socket.accept client.binmode begin line = client.readline rescue EOFError return nil end begin doc = Utils::JSON.parse(line) rescue RuntimeError => e client.write(Utils::JSON.generate( :result => 'error', :message => "JSON parse error: #{e}" )) end if doc['command'] == 'spawn' handle_spawn_command(client, doc, options) else client.write(Utils::JSON.generate( :result => 'error', :message => "Unknown command #{doc['command'].inspect}" )) nil end ensure if client begin client.close rescue Errno::EINVAL # Work around OS X bug. # https://code.google.com/p/phusion-passenger/issues/detail?id=854 end end end def handle_spawn_command(client, doc, options) work_dir = doc['work_dir'] LoaderSharedHelpers.record_journey_step_end('PRELOADER_PREPARATION', 'STEP_PERFORMED', work_dir) LoaderSharedHelpers.record_journey_step_begin('PRELOADER_FORK_SUBPROCESS', 'STEP_IN_PROGRESS', work_dir) # Improve copy-on-write friendliness. GC.start begin pid = fork rescue SystemCallError => e LoaderSharedHelpers.record_journey_step_end('PRELOADER_FORK_SUBPROCESS', 'STEP_ERRORED', work_dir) raise e end if pid.nil? begin LoaderSharedHelpers.rename_process "#{pre_name(options)} (forking...)" LoaderSharedHelpers.record_journey_step_end('PRELOADER_FORK_SUBPROCESS', 'STEP_PERFORMED', work_dir) LoaderSharedHelpers.run_block_and_record_step_progress('PRELOADER_SEND_RESPONSE', work_dir) do client.write(Utils::JSON.generate( :result => 'ok', :pid => Process.pid )) end LoaderSharedHelpers.record_journey_step_end('PRELOADER_FINISH', 'STEP_PERFORMED', work_dir) [:forked, work_dir] rescue Exception => e STDERR.puts("Error: #{e}\n#{e.backtrace.join("\n")}") exit!(1) end elsif defined?(NativeSupport) NativeSupport.detach_process(pid) else Process.detach(pid) end end def advertise_sockets(_options, server) json = { :sockets => [ { :name => 'main', :address => "unix:#{server[1]}", :protocol => 'preloader', :concurrency => 1 } ] } File.open(ENV['PASSENGER_SPAWN_WORK_DIR'] + '/response/properties.json', 'w') do \|f\| f.write(PhusionPassenger::Utils::JSON.generate(json)) end end def run_main_loop(server, options) server_socket, socket_filename = server original_pid = Process.pid while true # We call ::select just in case someone overwrites the global select() # function by including ActionView::Helpers in the wrong place. # https://code.google.com/p/phusion-passenger/issues/detail?id=915 ios = Kernel.select([server_socket, STDIN])[0] if ios.include?(server_socket) result, subprocess_work_dir = accept_and_process_next_client(server_socket, options) if result == :forked return subprocess_work_dir end end if ios.include?(STDIN) if STDIN.tty? begin # Prevent bash from exiting when we press Ctrl-D. STDIN.read_nonblock(1) rescue Errno::EAGAIN # Do nothing. end end break end end nil ensure server_socket.close if server_socket if original_pid == Process.pid File.unlink(socket_filename) rescue nil end end private def pre_name(options) "#{SHORT_PROGRAM_NAME} AppPreloader: #{options['app_root']}" end end end # module PhusionPassenger	6.25 KB	2025-11-20 11:36
📄 public_api.rb # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2010-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 class << self @@event_starting_worker_process = [] @@event_stopping_worker_process = [] @@event_starting_request_handler_thread = [] @@event_credentials = [] @@event_after_installing_signal_handlers = [] @@event_oob_work = [] @@event_unhandled_exception_before_exit = [] @@advertised_concurrency_level = nil def on_event(name, &block) callback_list_for_event(name) << block end def call_event(name, args) callback_list_for_event(name).each do \|callback\| callback.call(args) end end # For backward compatibility def install_framework_extensions!(user_options = {}) end def advertised_concurrency_level @@advertised_concurrency_level end def advertised_concurrency_level=(value) @@advertised_concurrency_level = value end private def callback_list_for_event(name) return case name when :starting_worker_process @@event_starting_worker_process when :stopping_worker_process @@event_stopping_worker_process when :starting_request_handler_thread @@event_starting_request_handler_thread when :credentials @@event_credentials when :after_installing_signal_handlers @@event_after_installing_signal_handlers when :oob_work @@event_oob_work when :unhandled_exception_before_exit @@event_unhandled_exception_before_exit else raise ArgumentError, "Unknown event name '#{name}'" end end end end # module PhusionPassenger	2.81 KB	2025-11-20 11:36
📁 rack	-	2026-03-21 15:53
📄 rack_handler.rb # frozen_string_literal: true # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2016-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. ## Magic comment: begin bootstrap ## libdir = File.expand_path('..', File.dirname(__FILE__)) $LOAD_PATH.unshift(libdir) begin require 'rubygems' rescue LoadError end require 'phusion_passenger' require_relative 'rack/handler' ## Magic comment: end bootstrap ## PhusionPassenger.locate_directories require 'rbconfig' require 'rackup' if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.4.0') # Rackup was removed in Rack 3, it is now a separate gem if Object.const_defined? :Rackup module Rackup module Handler module PhusionPassenger class << self include ::PhusionPassenger::Rack::Handler end end def self.default(options = {}) ::Rackup::Handler::PhusionPassenger end register :passenger, PhusionPassenger end end elsif Object.const_defined?(:Rack) && Rack.release < '3' module Rack module Handler module PhusionPassenger class << self include ::PhusionPassenger::Rack::Handler end end def self.default(options = {}) ::Rack::Handler::PhusionPassenger end end end ::Rack::Handler.register(:passenger, ::Rack::Handler::PhusionPassenger) else raise 'Rack 3 must be used with the Rackup gem' end	2.51 KB	2025-11-20 11:36
📁 request_handler	-	2026-03-21 15:53
📄 request_handler.rb # encoding: binary # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2010-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. require 'socket' require 'fcntl' PhusionPassenger.require_passenger_lib 'constants' PhusionPassenger.require_passenger_lib 'public_api' PhusionPassenger.require_passenger_lib 'message_client' PhusionPassenger.require_passenger_lib 'debug_logging' PhusionPassenger.require_passenger_lib 'native_support' PhusionPassenger.require_passenger_lib 'utils' PhusionPassenger.require_passenger_lib 'ruby_core_enhancements' PhusionPassenger.require_passenger_lib 'ruby_core_io_enhancements' PhusionPassenger.require_passenger_lib 'request_handler/thread_handler' module PhusionPassenger class RequestHandler include DebugLogging include Utils # Signal which will cause the application to exit immediately. HARD_TERMINATION_SIGNAL = "SIGTERM" BACKLOG_SIZE = 500 # String constants which exist to relieve Ruby's garbage collector. IGNORE = 'IGNORE' # :nodoc: DEFAULT = 'DEFAULT' # :nodoc: # A hash containing all server sockets that this request handler listens on. # The hash is in the form of: # # { # name1 => [socket_address1, socket_type1, socket1], # name2 => [socket_address2, socket_type2, socket2], # ... # } # # +name+ is a Symbol. +socket_addressx+ is the address of the socket, # +socket_typex+ is the socket's type (either 'unix' or 'tcp') and # +socketx+ is the actual socket IO objec. # There's guaranteed to be at least one server socket, namely one with the # name +:main+. attr_reader :server_sockets attr_reader :concurrency # A password with which clients must authenticate. Default is unauthenticated. attr_accessor :connect_password # Create a new RequestHandler with the given owner pipe. # +owner_pipe+ must be the readable part of a pipe IO object. # # Additionally, the following options may be given: # - connect_password def initialize(owner_pipe, options = {}) require_option(options, "app_group_name") install_options_as_ivars(self, options, "app", "app_group_name", "connect_password" ) @keepalive = options.fetch("keepalive", true).to_s == "true" @force_http_session = ENV["_PASSENGER_FORCE_HTTP_SESSION"] == "true" if @force_http_session @connect_password = nil end @thread_handler = options["thread_handler"] \|\| ThreadHandler @concurrency = 1 ############# ############# @server_sockets = {} if should_use_unix_sockets? @main_socket_address, @main_socket = create_unix_socket_on_filesystem(options) else @main_socket_address, @main_socket = create_tcp_socket(options) end @server_sockets[:main] = { :address => @main_socket_address, :socket => @main_socket, :protocol => @force_http_session ? :http : :session, :concurrency => @concurrency, :accept_http_requests => true } @http_socket_address, @http_socket = create_tcp_socket(options) @server_sockets[:http] = { :address => @http_socket_address, :socket => @http_socket, :protocol => :http, :concurrency => 1 } @owner_pipe = owner_pipe @options = options @previous_signal_handlers = {} @main_loop_generation = 0 @main_loop_thread_lock = Mutex.new @main_loop_thread_cond = ConditionVariable.new @threads = [] @threads_mutex = Mutex.new @main_loop_running = false ############# end # Clean up temporary stuff created by the request handler. # # If the main loop was started by #main_loop, then this method may only # be called after the main loop has exited. # # If the main loop was started by #start_main_loop_thread, then this method # may be called at any time, and it will stop the main loop thread. def cleanup if @main_loop_thread @main_loop_thread_lock.synchronize do @graceful_termination_pipe[1].close rescue nil end @main_loop_thread.join end @server_sockets.each_value do \|info\| socket = info[:socket] type = get_socket_address_type(info[:address]) begin socket.close if !socket.closed? rescue Exception => e # Ignore "stream closed" error, which occurs in some unit tests. # We catch Exception here instead of IOError because of a Ruby 1.8.7 bug. if e.to_s !~ /stream closed/ && e.message.to_s !~ /stream closed/ raise e end end if type == :unix filename = info[:address].sub(/^unix:/, '') File.unlink(filename) rescue nil end end @owner_pipe.close rescue nil end # Check whether the main loop's currently running. def main_loop_running? @main_loop_thread_lock.synchronize do return @main_loop_running end end # Enter the request handler's main loop. def main_loop debug("Entering request handler main loop") reset_signal_handlers begin @graceful_termination_pipe = IO.pipe @graceful_termination_pipe[0].close_on_exec! @graceful_termination_pipe[1].close_on_exec! @main_loop_thread_lock.synchronize do @main_loop_generation += 1 @main_loop_running = true @main_loop_thread_cond.broadcast @select_timeout = nil @selectable_sockets = [] @server_sockets.each_value do \|value\| socket = value[2] @selectable_sockets << socket if socket end @selectable_sockets << @owner_pipe @selectable_sockets << @graceful_termination_pipe[0] end install_useful_signal_handlers start_threads wait_until_termination_requested wait_until_all_threads_are_idle terminate_threads debug("Request handler main loop exited normally") rescue EOFError # Exit main loop. trace(2, "Request handler main loop interrupted by EOFError exception") rescue Interrupt # Exit main loop. trace(2, "Request handler main loop interrupted by Interrupt exception") rescue SignalException => signal trace(2, "Request handler main loop interrupted by SignalException") if signal.message != HARD_TERMINATION_SIGNAL raise end rescue Exception => e trace(2, "Request handler main loop interrupted by #{e.class} exception") raise ensure debug("Exiting request handler main loop") revert_signal_handlers @main_loop_thread_lock.synchronize do @graceful_termination_pipe[1].close rescue nil @graceful_termination_pipe[0].close rescue nil @selectable_sockets = [] @main_loop_generation += 1 @main_loop_running = false @main_loop_thread_cond.broadcast end end end # Start the main loop in a new thread. This thread will be stopped by #cleanup. def start_main_loop_thread current_generation = @main_loop_generation @main_loop_thread = create_thread_and_abort_on_exception do main_loop end @main_loop_thread_lock.synchronize do while @main_loop_generation == current_generation @main_loop_thread_cond.wait(@main_loop_thread_lock) end end end private def should_use_unix_sockets? # Historical note: # There seems to be a bug in MacOS X Leopard w.r.t. Unix server # sockets file descriptors that are passed to another process. # Usually Unix server sockets work fine, but when they're passed # to another process, then clients that connect to the socket # can incorrectly determine that the client socket is closed, # even though that's not actually the case. More specifically: # recv()/read() calls on these client sockets can return 0 even # when we know EOF is not reached. # # The ApplicationPool infrastructure used to connect to a backend # process's Unix socket in the Passenger core process, and then # pass the connection file descriptor to the web server, which # triggers this kernel bug. We used to work around this by using # TCP sockets instead of Unix sockets; TCP sockets can still fail # with this fake-EOF bug once in a while, but not nearly as often # as with Unix sockets. # # This problem no longer applies today. The web server now passes # all I/O through the Passenger core, and the bug is no longer # triggered. Nevertheless, we keep this function intact so that # if something like this ever happens again, we know why, and we # can easily reactivate the workaround. Or maybe if we just need # TCP sockets for some other reason. #return RUBY_PLATFORM !~ /darwin/ ruby_engine = defined?(RUBY_ENGINE) ? RUBY_ENGINE : "ruby" # Unix domain socket implementation on JRuby # is still bugged as of version 1.7.0. They can # cause unexplicable freezes when used in combination # with threading. # It's also bugged in Windows Subsystem for Linux # as of Windows 10, version 1803 (Fall Creators Update) # You will get "Address In Use" errors even if the port is unused. return !@force_http_session && ruby_engine != "jruby" && !PlatformInfo.windows_subsystem? end def create_unix_socket_on_filesystem(options) if defined?(NativeSupport) unix_path_max = NativeSupport::UNIX_PATH_MAX else unix_path_max = options.fetch('UNIX_PATH_MAX', 100).to_i end if options['socket_dir'] socket_dir = options['socket_dir'] socket_prefix = "ruby" else socket_dir = Dir.tmpdir socket_prefix = "PsgRubyApp" end retry_at_most(128, Errno::EADDRINUSE) do socket_address = "#{socket_dir}/#{socket_prefix}.#{generate_random_id(:base64)}" socket_address = socket_address.slice(0, unix_path_max - 10) socket = UNIXServer.new(socket_address) socket.listen(BACKLOG_SIZE) socket.binmode socket.sync = true socket.close_on_exec! File.chmod(0600, socket_address) ["unix:#{socket_address}", socket] end end def create_tcp_socket(options) # We default to "127.0.0.1" as address in order to force # TCPv4 instead of TCPv6. bind_address = options.fetch('bind_address', '127.0.0.1') socket = TCPServer.new(bind_address, 0) socket.listen(BACKLOG_SIZE) socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1) socket.binmode socket.sync = true socket.close_on_exec! socket_address = "tcp://#{bind_address}:#{socket.addr[1]}" return [socket_address, socket] end # Reset signal handlers to their default handler, and install some # special handlers for a few signals. The previous signal handlers # will be put back by calling revert_signal_handlers. def reset_signal_handlers Signal.list_trappable.each_key do \|signal\| begin prev_handler = trap(signal, DEFAULT) if prev_handler != DEFAULT @previous_signal_handlers[signal] = prev_handler end rescue ArgumentError # Signal cannot be trapped; ignore it. end end trap('HUP', IGNORE) PhusionPassenger.call_event(:after_installing_signal_handlers) end def install_useful_signal_handlers trappable_signals = Signal.list_trappable trap('ABRT') do print_status_report abort end if trappable_signals.has_key?('ABRT') trap('QUIT') do print_status_report end if trappable_signals.has_key?('QUIT') end def revert_signal_handlers @previous_signal_handlers.each_pair do \|signal, handler\| trap(signal, handler) end end def print_status_report warn(Utils.global_backtrace_report) warn("Threads: #{@threads.inspect}") end def start_threads common_options = { :app => @app, :app_group_name => @app_group_name, :connect_password => @connect_password, :keepalive_enabled => @keepalive } main_socket_options = common_options.merge( :server_socket => @main_socket, :socket_name => "main socket", :protocol => @server_sockets[:main][:protocol] == :session ? :session : :http ) http_socket_options = common_options.merge( :server_socket => @http_socket, :socket_name => "HTTP socket", :protocol => :http ) # Used for marking threads that have finished initializing, # or failed during initialization. Threads that are not yet done # are not in `initialization_state`. Threads that have succeeded # set their own state to true. Threads that have failed set their # own state to false. initialization_state_mutex = Mutex.new initialization_state_cond = ConditionVariable.new initialization_state = {} set_initialization_state = lambda do \|value\| initialization_state_mutex.synchronize do initialization_state[Thread.current] = value initialization_state_cond.signal end end set_initialization_state_to_true = lambda do set_initialization_state.call(true) end # Actually start all the threads. thread_handler = @thread_handler expected_nthreads = 0 @threads_mutex.synchronize do @concurrency.times do \|i\| thread = create_thread_and_abort_on_exception(i) do \|number\| begin Thread.current[:name] = "Worker #{number + 1}" handler = thread_handler.new(self, main_socket_options) handler.install handler.main_loop(set_initialization_state_to_true) ensure set_initialization_state.call(false) unregister_current_thread end end @threads << thread expected_nthreads += 1 end thread = create_thread_and_abort_on_exception do begin Thread.current[:name] = "HTTP helper worker" handler = thread_handler.new(self, http_socket_options) handler.install handler.main_loop(set_initialization_state_to_true) ensure set_initialization_state.call(false) unregister_current_thread end end @threads << thread expected_nthreads += 1 end # Wait until all threads have finished starting. initialization_state_mutex.synchronize do while initialization_state.size != expected_nthreads initialization_state_cond.wait(initialization_state_mutex) end end end def unregister_current_thread @threads_mutex.synchronize do @threads.delete(Thread.current) end end def wait_until_termination_requested ruby_engine = defined?(RUBY_ENGINE) ? RUBY_ENGINE : "ruby" if ruby_engine == "jruby" # On JRuby, selecting on an input TTY always returns, so # we use threads to do the job. owner_pipe_watcher = IO.pipe owner_pipe_watcher_thread = create_thread_and_abort_on_exception do Thread.current[:name] = "Owner pipe waiter" begin @owner_pipe.read(1) ensure owner_pipe_watcher[1].write('x') end end begin ios = select([owner_pipe_watcher[0], @graceful_termination_pipe[0]])[0] if ios.include?(owner_pipe_watcher[0]) trace(2, "Owner pipe closed") else trace(2, "Graceful termination pipe closed") end ensure owner_pipe_watcher_thread.kill owner_pipe_watcher_thread.join owner_pipe_watcher[0].close if !owner_pipe_watcher[0].closed? owner_pipe_watcher[1].close if !owner_pipe_watcher[1].closed? end else ios = select([@owner_pipe, @graceful_termination_pipe[0]])[0] if ios.include?(@owner_pipe) trace(2, "Owner pipe closed") else trace(2, "Graceful termination pipe closed") end end end def wakeup_all_threads threads = [] if get_socket_address_type(@server_sockets[:main][:address]) == :unix && !File.exist?(@server_sockets[:main][:address].sub(/^unix:/, '')) # It looks like someone deleted the Unix domain socket we listen on. # This makes it impossible to wake up the worker threads gracefully, # so we hard kill them. warn("Unix domain socket gone; force aborting all threads") @threads_mutex.synchronize do @threads.each do \|thread\| thread.raise(RuntimeError.new("Force abort")) end end else @concurrency.times do threads << create_thread_and_abort_on_exception(@server_sockets[:main][:address]) do \|address\| begin debug("Shutting down worker thread by connecting to #{address}") connect_to_server(address).close rescue Errno::ECONNREFUSED debug("Worker thread listening on #{address} already exited") rescue SystemCallError, IOError => e debug("Error shutting down worker thread (#{address}): #{e} (#{e.class})") end end end end threads << create_thread_and_abort_on_exception(@server_sockets[:http][:address]) do \|address\| begin debug("Shutting down HTTP thread by connecting to #{address}") connect_to_server(address).close rescue Errno::ECONNREFUSED debug("Worker thread listening on #{address} already exited") rescue SystemCallError, IOError => e debug("Error shutting down HTTP thread (#{address}): #{e} (#{e.class})") end end return threads end def terminate_threads debug("Stopping all threads") threads = @threads_mutex.synchronize do @threads.dup end threads.each do \|thr\| thr.raise(ThreadHandler::Interrupted.new) end threads.each do \|thr\| thr.join end debug("All threads stopped") end def wait_until_all_threads_are_idle debug("Waiting until all threads have become idle...") # We wait until 100 ms have passed since all handlers have become # interruptable and remained in the same iterations. done = false while !done handlers = @threads_mutex.synchronize do @threads.map do \|thr\| thr[:passenger_thread_handler] end end debug("There are currently #{handlers.size} threads") if handlers.empty? # There are no threads, so we're done. done = true break end # Record initial state. handlers.each { \|h\| h.stats_mutex.lock } iterations = handlers.map { \|h\| h.iteration } handlers.each { \|h\| h.stats_mutex.unlock } start_time = Time.now sleep 0.01 while true if handlers.size != @threads_mutex.synchronize { @threads.size } debug("The number of threads changed. Restarting waiting algorithm") break end # Record current state. handlers.each { \|h\| h.stats_mutex.lock } all_interruptable = handlers.all? { \|h\| h.interruptable } new_iterations = handlers.map { \|h\| h.iteration } # Are all threads interruptable and has there been no activity # since last time we checked? if all_interruptable && new_iterations == iterations # Yes. If enough time has passed then we're done. handlers.each { \|h\| h.stats_mutex.unlock } if Time.now >= start_time + 0.1 done = true break end else # No. We reset the timer and check again later. handlers.each { \|h\| h.stats_mutex.unlock } iterations = new_iterations start_time = Time.now sleep 0.01 end end end debug("All threads are now idle") end end end # module PhusionPassenger	21.4 KB	2025-11-20 11:36
📄 ruby_core_enhancements.rb # encoding: binary # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2010-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. begin require 'rubygems' rescue LoadError end require 'socket' require 'thread' if (!defined?(RUBY_ENGINE) \|\| RUBY_ENGINE == "ruby") && RUBY_VERSION < "1.8.7" begin require 'fastthread' rescue LoadError abort "You are using a very old Ruby version. You must install " + "the 'fastthread' gem to fix some bugs in the Ruby threading system: " + "gem install fastthread" end end require 'pathname' class Exception def backtrace_string(current_location = nil) if current_location.nil? location = nil else location = "in #{current_location} " end current_thread = Thread.current if !(thread_id = current_thread[:id]) current_thread.to_s =~ /:(0x[0-9a-f]+)/i thread_id = $1 \|\| '?' end if thread_name = current_thread[:name] thread_name = "(#{thread_name})" end return "*** Exception #{self.class} #{location}" << "(#{self}) (process #{$$}, thread #{thread_id}#{thread_name}):\n" << "\tfrom " << backtrace.join("\n\tfrom ") end end class Dir # The current working directory may contain one or more symlinks # in its path. Both Dir.pwd and the C getcwd() call resolve symlinks # in the path. # # It turns out that there is no such thing as a path without # unresolved symlinks. The shell presents a working directory with # unresolved symlinks (which it calls the "logical working directory"), # but that is an illusion provided by the shell. The shell reports # the logical working directory though the PWD environment variable. # # This method tries to use the PWD environment variable if it # matches the actual working directory. # # See also: # https://github.com/phusion/passenger/issues/1596#issuecomment-138154045 # http://git.savannah.gnu.org/cgit/coreutils.git/tree/src/pwd.c # http://www.opensource.apple.com/source/shell_cmds/shell_cmds-170/pwd/pwd.c def self.logical_pwd physical_pwd = Dir.pwd logical_pwd = ENV['PWD'] if logical_pwd.nil? \|\| logical_pwd.empty? return physical_pwd end # Check whether $PWD matches the actual working directory. # This algorithm similar to the one used by GNU coreutils. begin logical_stat = File.stat(logical_pwd) physical_stat = File.stat(physical_pwd) if logical_stat.ino == physical_stat.ino && logical_stat.dev == physical_stat.dev logical_pwd else physical_pwd end rescue SystemCallError physical_pwd end end end class File # Dir.pwd resolves symlinks. So in turn, File.expand_path/File.absolute_path # do that too. This method fixes that by using Dir.logical_pwd. if File.respond_to?(:absolute_path) def self.absolute_logical_path(path, base = Dir.logical_pwd) return File.absolute_path(path, base) end else def self.absolute_logical_path(path, base = Dir.logical_pwd) return File.expand_path(path, base) end end end module Signal # Like Signal.list, but only returns signals that we can actually trap. def self.list_trappable ruby_engine = defined?(RUBY_ENGINE) ? RUBY_ENGINE : "ruby" case ruby_engine when /jruby/ result = Signal.list.dup result.delete("QUIT") result.delete("ILL") result.delete("FPE") result.delete("SEGV") result.delete("USR1") result.delete("IOT") else result = Signal.list.dup result.delete("ALRM") result.delete("VTALRM") end # Don't touch SIGCHLD no matter what! On OS X waitpid() will # malfunction if SIGCHLD doesn't have a correct handler. result.delete("CLD") result.delete("CHLD") # Other stuff that we don't want to trap no matter which # Ruby engine. result.delete("STOP") result.delete("KILL") result.delete("EXIT") # Profilers such as ddtrace and stackprof use this signal, so removing the # the handler causes the Ruby process to crash when profilers are operating. # See https://github.com/phusion/passenger/issues/2489 for details. result.delete("PROF") return result end end module GC if !respond_to?(:copy_on_write_friendly?) # Checks whether the current Ruby interpreter's garbage # collector is copy-on-write friendly. def self.copy_on_write_friendly? return false end end end	5.5 KB	2025-11-20 11:36
📄 ruby_core_io_enhancements.rb # encoding: binary # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2010-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. PhusionPassenger.require_passenger_lib 'native_support' class IO if defined?(PhusionPassenger::NativeSupport) # Writes all of the strings in the +components+ array into the given file # descriptor using the +writev()+ system call. Unlike IO#write, this method # does not require one to concatenate all those strings into a single buffer # in order to send the data in a single system call. Thus, #writev is a great # way to perform zero-copy I/O. # # Unlike the raw writev() system call, this method ensures that all given # data is written before returning, by performing multiple writev() calls # and whatever else is necessary. # # io.writev(["hello ", "world", "\n"]) def writev(components) return PhusionPassenger::NativeSupport.writev(fileno, components) end # Like #writev, but accepts two arrays. The data is written in the given order. # # io.writev2(["hello ", "world", "\n"], ["another ", "message\n"]) def writev2(components, components2) return PhusionPassenger::NativeSupport.writev2(fileno, components, components2) end # Like #writev, but accepts three arrays. The data is written in the given order. # # io.writev3(["hello ", "world", "\n"], # ["another ", "message\n"], # ["yet ", "another ", "one", "\n"]) def writev3(components, components2, components3) return PhusionPassenger::NativeSupport.writev3(fileno, components, components2, components3) end else def writev(components) return write(components.pack('a' components.size)) end def writev2(components, components2) joined = components + components2 return write(joined.pack('a' joined.size)) end def writev3(components, components2, components3) joined = components + components2 + components3 return write(joined.pack('a' joined.size)) end end if IO.method_defined?(:close_on_exec=) def close_on_exec! begin self.close_on_exec = true rescue NotImplementedError end end else require 'fcntl' if defined?(Fcntl::F_SETFD) def close_on_exec! fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC) end else def close_on_exec! end end end end	3.53 KB	2025-11-20 11:36
📄 simple_benchmarking.rb # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2010-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. class Object # :nodoc: @@benchmark_results = {} def b!(name) time1 = Time.now begin yield ensure time2 = Time.now @@benchmark_results[name] = 0 unless @@benchmark_results.has_key?(name) @@benchmark_results[name] += time2 - time1 end end def benchmark_report(main = nil) total = 0 if main.nil? @@benchmark_results.each_value do \|time\| total += time end else total = @@benchmark_results[main] end @@benchmark_results.each_pair do \|name, time\| printf "%-12s: %.4f (%.2f%%)\n", name, time, time / total * 100 end printf "-- Total: %.4f\n", total end end	1.9 KB	2025-11-20 11:36
📁 standalone	-	2026-03-21 15:53
📁 utils	-	2026-03-21 15:53
📄 utils.rb # encoding: binary # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2010-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 # Utility functions. module Utils extend self # Make methods available as class methods. def self.included(klass) # When included into another class, make sure that Utils # methods are made private. public_instance_methods(false).each do \|method_name\| klass.send(:private, method_name) end end # Generate a long, cryptographically secure random ID string, which # is also a valid filename. def generate_random_id(method) data = File.open("/dev/urandom", "rb") do \|f\| f.read(64) end case method when :base64 data = base64(data) data.gsub!("+", '') data.gsub!("/", '') data.gsub!(/==$/, '') return data when :hex return data.unpack('H')[0] else raise ArgumentError, "Invalid method #{method.inspect}" end end def retry_at_most(n, exceptions) n.times do \|i\| begin return yield rescue exceptions if i == n - 1 raise end end end end # Print the given exception, including the stack trace, to STDERR. # # +current_location+ is a string which describes where the code is # currently at. Usually the current class name will be enough. # It may be nil. # # This method requires 'ruby_core_enhancements'. If 'debug_logging' # is loaded and included in the current module, it will use that for # logging. def print_exception(current_location, exception, destination = nil) if !exception.is_a?(SystemExit) data = exception.backtrace_string(current_location) if defined?(DebugLogging) && self.is_a?(DebugLogging) error(data) else destination \|\|= STDERR destination.puts(data) destination.flush if destination.respond_to?(:flush) end end end # A wrapper around Thread.new that installs a default exception handler. # If an uncaught exception is encountered, it will immediately log the # exception and abort the entire program. # # Thread#abort_on_exception is also supposed to do that, but the problem # is that it is implemented by forwarding the uncaught exception # to the main thread, which may not expect that particular exception # and may not handle it properly. The exception could be forwarded to # the main thread during any point of the main thread's execution. # # This method requires 'thread' and 'ruby_core_enhancements'. # If 'debug_logging' is loaded and included in the current module, # it will use that for logging. def create_thread_and_abort_on_exception(args) Thread.new do Thread.current.abort_on_exception = true begin yield(args) rescue SystemExit raise rescue Exception => e print_exception(nil, e) PhusionPassenger.call_event(:unhandled_exception_before_exit, e) exit(1) end end end def get_socket_address_type(address) if address =~ %r{^unix:.} return :unix elsif address =~ %r{^tcp://.} return :tcp else return :unknown end end def connect_to_server(address) case get_socket_address_type(address) when :unix return UNIXSocket.new(address.sub(/^unix:/, '')) when :tcp host, port = address.sub(%r{^tcp://}, '').split(':', 2) port = port.to_i return TCPSocket.new(host, port) else raise ArgumentError, "Unknown socket address type for '#{address}'." end end def local_socket_address?(address) case get_socket_address_type(address) when :unix return true when :tcp host, port = address.sub(%r{^tcp://}, '').split(':', 2) return host == "127.0.0.1" \|\| host == "::1" \|\| host == "localhost" else raise ArgumentError, "Unknown socket address type for '#{address}'." end end # Checks whether the given process exists. def process_is_alive?(pid) begin Process.kill(0, pid) return true rescue Errno::ESRCH return false rescue SystemCallError => e return true end end def require_option(hash, key) if hash.has_key?(key) return hash[key] else raise ArgumentError, "Option #{key.inspect} required" end end def install_options_as_ivars(object, options, keys) keys.each do \|key\| object.instance_variable_set("@#{key}", options[key]) end end # Returns a base64 encoded string without line breaks and padding. # Like Base64.strict_encode64, but without a dependency on the # 'base64' library/gem. def base64(data) [data].pack("m0") end # Returns a string which reports the backtraces for all threads, # or if that's not supported the backtrace for the current thread. def global_backtrace_report if Kernel.respond_to?(:caller_for_all_threads) all_thread_stacks = caller_for_all_threads elsif Thread.respond_to?(:list) && Thread.public_method_defined?(:backtrace) all_thread_stacks = {} Thread.list.each do \|thread\| all_thread_stacks[thread] = thread.backtrace end end output = "========== Process #{Process.pid}: backtrace dump ==========\n" if all_thread_stacks all_thread_stacks.each_pair do \|thread, stack\| if thread_name = thread[:name] thread_name = "(#{thread_name})" end stack \|\|= ["(empty)"] output << ("-" * 60) << "\n" output << "# Thread: #{thread.inspect}#{thread_name}, " if thread == Thread.main output << "[main thread], " end if thread == Thread.current output << "[current thread], " end output << "alive = #{thread.alive?}\n" output << ("-" * 60) << "\n" output << " " << stack.join("\n ") output << "\n\n" end else output << ("-" * 60) << "\n" output << "# Current thread: #{Thread.current.inspect}\n" output << ("-" * 60) << "\n" output << " " << caller.join("\n ") end return output end #################################### end end # module PhusionPassenger	7.6 KB	2025-11-20 11:36
📁 vendor	-	2026-03-21 15:53

Edit File:

Terminal